Welcome to the dregs of my mind

What ever happened to days gone by?

Renraku OS: The Way Up
Eye Am

 It's now been just over a month since this iteration of the Renraku
project began. In that time, we've made monumental progress in
effectively every way. We're up to 4 developers and a designer (see
the pretty logo?), we've started to solidify the actual design of the
codebase and how it's going to function in the future, and we're
steadily pushing toward being a usable OS. We have a very long path
ahead of us, but we're iterating quickly.

 Today, we're proud to announce the release of Renraku OS version 0.2
alpha, codenamed "The Way Up".

 What's new:

  • Services – allow the interface to be decoupled from the implementation and provide a model for drivers, filesystems, network servers, etc.
  • Contexts – allow applications (Capsules, in Renraku terminology) to access services, and allows nesting such that you can run a Capsule in a sandbox where you provide filtered services, e.g. transparent proxying, nested windows, etc.
  • Mouse support – Renraku now supports PS/2 mice via a simple service interface.
  • VGA and general video interface – We can now use the latest in video technology (320x200 VGA, of course) in Renraku applications, even features double buffering. Progress is underway by one of our developers to build a basic GUI, but we have a few example apps.
  • BCL improvements – We've been gradually implementing various collections (ArrayList, Queue), text helpers (StringBuilder), and other pieces of the BCL, as we make the development process higher and higher level.
  • Compiler improvements – Inheritance, enums, interface implementation, method overloading, and many other things now work perfectly. There are now only a few key components (reflection and generics being the two big ones) missing before the compiler is effectively functionally complete.
  • Bootable ISO building – You can now build bootable ISOs along with the kernel image.
  • New apps to test out our new functionality:
    • 'exclaim' – Example nested Context application, turning your '1's into '!'s by hooking the keyboard service. Screenshot
    • 'draw' – Simple bouncing box VGA demo. Screenshot
    • 'mouse' – Control a box cursor with your mouse, changing the colors with the click of a button. Screenshot 1 Screenshot 2
    • 'logo' – Renders our logo in beautifully dithered 256 color VGA. Screenshot

 You can get a bootable ISO or check out the tree at Github. We'd love to hear what you think; drop by our IRC
channel, irc://irc.freenode.net/renraku. If you run into
any bugs, feel free to throw them on our issue tracker.

 You can also see the complete screenshot gallery as well as a few shots of Renraku running on real hardware.

 We've had fun building it, I hope you have fun playing around with it.

 Happy Hacking,
- Cody Brocious (Daeken)

Posted via email from I, Hacker

Renraku OS: Initial Release
Eye Am

The Renraku OS team is proud to announce the first release, 0.1alpha.
Major strides have been made in the two weeks since the new codebase
was started, and we're very happy with where things are.
We now have:
  • Initial compiler with support for vtables, a good chunk of the CIL instruction set, string object constants, etc.
  • Initial memory manager (real memory manager is in progress).
  • Basic object manager.
  • The start of System.Array/String/Console.
  • Keyboard driver and US English keymap.
  • Basic shell that can execute applications.
  • Basic HAL and interfaces for timer, keyboard, and network drivers.
  • Initial PCI base class.
  • A few simple applications:
    • 'echo' – Echo terminal
    • 'reverse' – Reverses the arguments passed to it
    • 'halstatus' – Prints the status of loaded drivers
    • 'pci' – Scans for PCI devices and dumps the vendor and device IDs
    • 'shell' – Creates a subshell

We've also created an IRC channel, #renraku on Freenode where
the developers are generally available. If you want to give it a
spin, grab the kernel image and boot it with GRUB. If you run into any problems, drop
us a line on the channel.
For the curious, you can check out this gallery of screenshots of the various commands. And as always, the
codebase is on Github.
Give it a shot and let us know what you think.
Happy hacking,
- Cody Brocious

Posted via email from I, Hacker

Renraku: It Lives!
Eye Am
This is a follow-up to my previous post, Renraku: Future OS.
I got the latest incarnation of Renraku booting yesterday, based on
the code base I started the same day I wrote the previous article.
There's not much to it, but development is progressing very, very
quickly since I have plenty of knowledge of what not to do from
previous attempts. What's there (in the GitHub repo)
now supports very basic functionality: multiple function compilation,
a good number of "Base instructions" (from the ECMA CIL spec), static
fields, pointer intrinsics, and string intrinsics (get_Chars for now).
The test kernel is available here (GitHub) and this boots as expected. Obviously, it doesn't do
much, but that's coming. What needs to be done in the short term:
  • Struct support
  • Struct pointers
  • Basic object manager

That's it. Once those are done, there's a primitive object model
which means actual functionality can be written. A few more days of
work, and we should be able to see a simple shell come up.
Happy Hacking,
- Cody Brocious (Daeken)

Posted via email from I, Hacker

Renraku: Future OS
Eye Am
Renraku is a family of managed research kernels I've been working on
for around 4 years. Though the goals and implementations have changed
over the years, they're all designed to be highly reliable, fast,
portable, and flexible enough to keep up with the changing needs of
today's technology.


Initially, Renraku (known as Colorblind at the time) was simply an
experiment. Inspired by Unununium in its Python era, I saw the value
in kernels being very high level. Ease of development, in the hands
of the right hacker, could mean vast improvements in a short period of
time. With this in mind, I set out to build a prototype. I built a
number of revisions on top of existing OSes, but in the end I couldn't
get the design I wanted. I shelved the project, but never forgot
about it.
Shortly thereafter, I started playing around with the development of
Talk, an L4-inspired microkernel. It was very simple, written in
straight x86 assembly, and was intended to see how small such a
microkernel could be without sacrificing critical functionality. It
didn't get far due to not having enough time, but while designing the
set of base services and their interactions, it made me think back to
It sat on the back burner for about a year and a half, until I saw
MSR's Singularity project, some time around 2006. At this point, I
started seriously thinking about what I want in a future OS and how I
can go about implementing it. I've since written a few prototypes in
a mix of C# and Nemerle, and the goals have largely solidified.


High level:
  • Pure managed code. No C, no assembly not generated by the compiler, no pointer access outside of the object manager and certain parts of the kernel.
  • Everything is an object. Turtles all the way down.
  • Single address space and no userland. Everything is ring 0.
  • Completely network-transparent objects.
  • Object store instead of a traditional filesystem.
  • System-wide orthogonal persistence.

  • Pure .NET. Currently playing around with Boo for it, due to their new macro syntax and functionality.
  • Ahead of time compilation for the base services.
  • Object model implemented on top of itself. That is, the object model is implemented in terms of value types and pointers, and the compiler has intrinsics for object model instructions to auto-call the implementation.
  • While designing/implementing any feature, now is always better than later. Always, always, always go for the practical, simple route before considering a more complex one.



This is a rough roadmap of the implementation of Renraku. How far
this ends up going is really up in the air; it could go to the end,
it could be abandoned half way and rewritten again. Eventually, I'd
love to see these ideas come to fruition, though.
  • Initial CIL->x86 compiler. Uses the actual stack to execute code, as optimizations can be added later.
  • Initial memory/object manager. Nothing fancy, just enough to get things up and running.
  • Begin implementing the .NET BCL. Get basic string manipulation and collections working.
  • Implement keyboard support.
  • Implement a basic shell. Allow object inspection/manipulation.
  • Implement initial object store.
  • Implement basic networking and network transparent objects.
  • Build framebuffer support and a basic GUI library.
  • Implement the dependencies of the Boo, C#, and Renraku compilers.
  • Implement a basic terminal and REPL.

Once these things are implemented, development should be able to
progress very rapidly. There's just a lot of work to do to get there.
What would you want to see in a future OS? What would you like to see
go away? What new UI paradigms ought to be used? I'd love to hear
feedback on this, as there's simply a lot to think about.
Happy Hacking,
- Cody Brocious (Daeken)

Posted via email from I, Hacker

Partially Destructive Garbage Collection
Eye Am
While laying in bed and trying to sleep last night, I had an idea I'd
like some feedback on. The idea is partially destructive garbage
collection, which allows the runtime to handle caching, instead of the
programmer. With PDGC, the runtime is allowed to destroy an object
and keep only the relevant data for recreation around. If you're
running a photo management application, for instance, you may want to
keep JPEGs and thumbnail bitmaps in memory, while not keeping the full
bitmap around. In theory, this is a problem that PDGC can solve for
At compile-time, the compiler can look at your class and determine
whether or not your object's creation has side-effects, or depends on
factors outside of its control (e.g. IO), and make a determination if
it's partially destroyable. If it is, then the compiler embeds code
into the constructor (and other relevant methods*) to save the data
needed to recreate the object. At run-time, the frequency of access,
object creation time, etc will be tracked, and the PDGC can make the
decision to destroy the object or keep it around. If the object is
destroyed, it doesn't entirely go away; rather, it's replaced with a
stand-in object that stores the relevant data for recreation.
Further ideas:
  • You could allow the PDGC to only destroy certain object properties, rather than the full object
  • A more general approach to language-level caching would allow the objects to be saved to disk and loaded lazily. This is something I plan to explore as part of my Renraku research kernel, the details of which I'll be posting on soon.

General open questions:
  • What research has been done on this previously? What were the findings?
  • How much of this belongs in the compiler and how much in the runtime? This obviously comes down to the implementation, but I believe there needs to be research into good, general approaches.

Implementation questions:
  • Should this be involved with the GC at all? In my mind, they're related, but in a specific implementation they may well be completely separated.
  • What factors are used in determining whether or not an object persists? Factors I can think of are: frequency of access, cost of object recreation, size, amount of free memory, amount of free swap space.
  • Should this be behind-the-scenes compiler magic, or should it be more user controllable? E.g. should the user be able to decide if an object is destroyable at a given point? Should the user be able to override the object recreation portion, rather than letting the constructor do its thing?

I'd love to hear your take on it.
Happy Hacking,
- Cody Brocious (Daeken)

Posted via email from I, Hacker

Eye Am

I've finally decided to take the plunge and move to Posterous.  If all goes according to plan, my posts from here should automagickly be crossposted to my Livejournal, but that's going to primarily become my personal blog; this blog will be used for all things tech/business.

To get things started, I'd like to introduce my new programming language, Ultilang.  The name is horrid, so please, add suggestions for a new one here: http://ultilang.wikia.com/wiki/NameIdeas.

Ultilang is a strange mix of Nemerle, Python, and Lisp.  A curly brace-based syntax, heavy metaprogramming, and multiple backends (.NET, JVM, Python, and JavaScript planned) come together into what I intend to be the most flexible, powerful language out there.  By leveraging features typically reserved for heavy-duty functional languages and blending them with the ease of use we've come to expect with languages like Python, I hope to create a language suitable for near every task.

The compiler, available at http://github.com/daeken/Ultilang/tree/master, is written in Python and builds/runs a Python AST.  It's currently in the early stages, having just been started yesterday; the first test, a simple recursive fibonacci sequence printer, runs perfectly.  There's a decent bit of work to do before the compiler can bootstrap up to Ultilang itself, but it's coming along nicely.

There's a list of planned/requested features at http://ultilang.wikia.com/wiki/Features; feel free to add your own.  Even if they don't end up in the language itself, they may well become a macro in one of the libraries.

Stay tuned for more information as the language progresses.

Posted via web from I, Hacker

WSOP Freerolls
Eye Am
So, I've been doing the WSOP Freerolls on Pokerstars, in an attempt to make it to the weekly final and possibly score a seat at the WSOP.  I've been gradually getting better and better, since yesterday was my first real tournament.  This last one, I placed 298 out of 10,000 players, having made it past the first round.  Not bad, but I need to step my game up a lot.

I slipped up and went in on some hands that weren't up to scratch.  Overall, I did damn well, but I'm really the only reason I lost, in the end.  I got shitty hands the whole first round (I got big slick once, but no one even bit at my tiny bet), but I played the hell out of them... second round, not so much.  I got several decent hands, but I misplayed them, and at one point I ended up down to the felt, which meant I had to play even smarter and get back in the game; that did not happen.

I'm going to go over my hand history and revise my strategy and, you know, actually stick to it next time around.

Belize pt. 3: Education for the masses
Eye Am
This is part three of my series on Belize.  You can read part one here: Belize, the next Silicon Valley? and part two here: Bootstrapping an economy into the 21st century.  As before, all figures are in USD.  One thing I've not yet mentioned explicitly in my posts is that everything I'm going to talk about requires the government to do absolutely nothing.  I may mention action the government can take, but in no case will it be required, and I believe the private sector solutions I'm suggesting will be far more benefitial to all parties involved.

In my previous post, I discussed the importance of building higher learning establishments.  However, I missed a very important fact: if you're attempting to boost the economy of a poor country, the people are generally going to be too poor to afford such education.

I really see two major routes for getting people educated:  student loans and subsidation by potential employers.  These are really quite similar, with the primary difference being who the debt is on.  With student loans, the debt is on the student and it's possible to charge interest; with employer-subsidized education, the debt is on the employer and they hope to pay it off with the fruits of the employee's labor.  Regardless, the employer wins out, as neither route would work if the employee becoming educated was a net negative for the lender.

All of this said, I think student loans are a bad solution.  Imagine the following scenario.  Ten established tech companies in Belize found a higher learning institute together, so they can train Belizeans to work in the industry rather than shipping in workers.  If they were to give student loans (let's assume these are interest-free for simplicity), the student is contractually bound to pay it back and even if the schooling costs $100k/yr, they will eventually get it back.  It doesn't really matter to the companies that it will take the student 20 years to pay it off, because they will eventually get it back, generally.

Now assume the companies pay for the education themselves, with the intention of paying it off with the money the worker makes them.  They have a vested interest in making the education as inexpensive and as high quality as possible.  The higher the quality of education, the easier it's going to be for the worker to make them money, and the less expensive it is, the sooner they're going to profit off the deal.  At the surface, they're 'loaning' money to the student, but the difference is that they only get paid if the terms of the deal are favorable to both parties.

It seems clear to me after consideration that the only way to successfully educate the masses of Belize is for the tech industry itself to subsidize the education.  What isn't clear to me is why this isn't the way things work elsewhere.

Belize pt. 2: Bootstrapping an economy into the 21st century
Eye Am
This is part two of my series on Belize. You can read part one here: Belize, the next Silicon Valley? As in the previous post, all figures are in USD.

As I detailed in my previous entry, Belize has a multitude of benefits to those looking for a tech start-up location. Little to no taxes, low cost of living, and cheap real estate. However, I deliberately neglected to touch on the negatives, as I think they're worthy of their own post.

The first big negative is expensive and outdated telecom infrastructure. BTL (Belize Telemedia Limited) has a monopoly on all things telecom and it shows.  It's difficult to pin down the exact figures as they stand now (BTL's pricing on their site was last updated in 2003), but it looks like about $100/mo for 1.5Mbit DSL.  That is simply abysmal, but it makes sense.  You have one big telecom company with no competition, mostly poor residents, and tourists with cash.

The second big problem is a severe lack of higher education.  I'm no fan of it in general (hard to be one when you never finished high school), but the effects are abundantly clear in Belize.  Skilled workers in the tech industry are effectively non-existent.  Of course, this makes sense, because Belize has no tech industry.  Why teach something that students will generally have to leave the country to practice?

I'm certain there are many other big problems I'm missing, but I'll start with these.  How do we solve them?

I think they can both be solved by one thing: start a tech industry.  The benefits to startups are such that I'm most certainly going to be moving there myself, soon.  If even a few startups spring up in Belize and succeed, the impact on the nation would be massive.

For the first problem, telecom infrastructure, it's a direct effect.  Companies spring up requiring better telecom infrastructure, and either BTL adapts or someone else sweeps in and provides it.  One thing is clear: there's no way these startups will be left in the dark.  There's simply too much money to be made, and the telecoms damn sure aren't getting it from the masons and fisherman as it stands.

The problem of education would be solved more slowly, but it seems like it'd happen.   If a decent number of medium-large tech companies pop up, they're going to need phone/email support staff, IT workers, programmers, electricians, salespeople, etc.  In the early days of this bootstrapping process, they'll come from the US and other countries where it's easy to immigrate to Belize, but that's a highly inefficient way of expanding.  Instead, I believe that higher learning establishments will either spring up anew or expand their existing programs.  More and more often, these jobs will be filled by Belizeans.

If you sustain this process for long enough, eventually you'll hit a tipping point.  Belizeans will start to build startups, staffed by other Belizeans, and the chain reaction will sustain itself.  Of course, where there's money in one industry, other industries will follow.  The quality of medical care will likely increase, you'll get better options for travel and lodging, etc.  All of this adds up to the cost of living, the GDP (which was a mere $2.5B in 2008), and the average wage will increase.  This is a Good Thing (TM).

I'm obviously biased towards the tech industry in general, but I really believe that the building of a tech industry in Belize could have a substantial positive impact on the country as a whole, over a short span of time, perhaps even as little as 10 or 15 years.

Belize, the next Silicon Valley?
Eye Am
I've been a proponent of Belize as a corporate tax haven for a while, due to the fact that you pay no taxes on foreign income, but it wasn't until recently that I started looking at it for residence.  What I found was the following (all figures are in USD):
  • Personal income tax is capped at 25% and doesn't apply to dividends from companies (meaning you can pay nothing if you start an IBC (international business company) and funnel your money through that), and there's no capital gains tax.
  • Property taxes are approx 1% of the value of the undeveloped land, when outside cities, and extraordinarily low even in cities.
  • Land, developed and not, is incredibly cheap.  You can pick up a nice house inland for US$20k, and you can buy undeveloped industrial land for $1-5k/acre, depending on location.
  • 3-4 bedroom houses can be rented for $250-500/mo, depending on location.
  • Immigrating to Belize is as simple as flying down there, getting a tourist visa, and then applying for residency after 6 months.  Citizenship can be applied for after 5 years.  It really comes down to this: if you want to move there, you simply have to pay for it, and you don't have to pay much.
All of this has me thinking, this all adds up to making it very cheap to build a startup.  Low taxes, cheap property, ease of immigration.  All of this is condusive to start-ups.

Imagine this, you and 2 other people want to start a tech company.  In any of the big tech hubs in the US, you're looking at spending at least $30k/yr per person (I'm being very conservative here), and you'll generally be living in at tiny apartment and eating ramen.  In addition, you'll be taxed out the ass.

Now imagine the same thing in Belize.  You can get a 2br house in most areas for $250/mo at most, you'll spend between $100-200/mo on food (really depends on how much you eat and how good you are at shopping around), you'll spend about $100/mo for a decent DSL connection, and you'll spend approximately $1500 on tourist visas, a work permit, and getting residency.  All of this adds up to living comfortably for $7500/yr (assuming about $150/mo on food) per person.

Now, if these same 3 founders were to get a nice sized 4br house together for $550/mo (which is easily doable) and upgrade the DSL a bit to compensate ($150/mo), you're looking at $6100/yr per person.

Regardless of which option you were to go with, one thing is abundantly clear:  a group of founders with $50k in the bank can easily live comfortably for 2 years in Belize with no outside income.  This combined with the complete lack of taxes on foreign income makes it a perfect location for tech companies.


Log in