Saying that everything should be public is certainly an idea that takes getting used to. It’s like saying that you should publish the details of your drunken escapades on your blog. It’s unsettling, but then again, the pictures are probably already on Facebook anyway. I think there are two issues here — one is for fields, and the other is for methods.

Though Steve seems to say that fields should be public (or have getters and setters on them), I personally tend to go the other way: fields should be private by default and only accessible through getters and setters. I like the way Ruby does it — everything is private by default but the accessors are generated by metaprogramming, so you don’t have the junk lines of getWhatever and setWhatever that you do with Java. Direct field accesses like Java and C++ allow are just bad ideas.

For methods things are the other way around. Firstly, I don’t like the idea of invoking methods on an object. I far prefer the Smalltalk notion of sending messages to objects and having them respond. I think it’s a far better conceptual model than methods and the private/public debate goes away in that model. If your object responds to methods, then being able to use private and public means that the object knows of and cares about where about the message is coming from. However, this breaks encapsulation. Ideally an object should respond to a particular message the same way irrespective of where the message comes from.

But, you say, what of the real world where ideals don’t necessarily hold? Hmm… let’s see what happens to software development under the assumption that all your methods and functions are callable from outside. To start off, you have to be careful about what parameters your methods take. You can’t assume that they’ve been pre-sanitized which means that either you’ll have to check them yourself or fail cleanly (and maybe send a stern warning up the chain). This may be a bit annoying, but I’d say it’s on the same level as dynamic typing — you’re never 100% sure of what type the arguments are so you take appropriate measures.

Now let’s talk about safety. One of the arguments in favor of private is that you don’t want methods to be abused and put the object in an unusable state. Again, I don’t think this is as big of a problem as it’s made up to be. It just involves rearranging where checking occurs. Presumably, if you have a private method that makes delicate changes to your object, you have a public method somewhere else that approves the changes and then calls said private method. Why not put the approval inside the private method and dispense with the public method entirely? If you want to make a change to an object, call a method to do it. If it works, fine. If not you get an error back.

I should make it clear at this point, that I don’t have any real world example to back up my claim (at least no examples that aren’t hopelessly contrived). What I’m talking is refactoring to meet a design constraint — that of total publicness. People will kick and scream and say that it breaks their careful separation of functionality into methods, but I think it’s just a design pattern, like dependency injection for example. And the trade-off to that is probably more flexible, more powerful software systems.

If everything is public (and designed from the ground up to be public) you start writing code that’s meant to be used by other code. Which in turn makes it easier to use and extend your code. I think you’ll eventually end up with something like Emacs — lots of public functions that do useful things to an object (the text in the editor) and an awesome array of functionality made possible by using these public functions. There is a fundamental change in programming and building ideology that needs to take place. With full publicness you can’t have a nicely bureaucratic language like Java. You’re going to end up with something that’s far more open and flexible like Ruby, Python or *shudder* Lisp.

I think that a lot of the heightened discussion surrounding Steve’s suggestion stems from the nature of the Java language. It’s certainly meant to be used by large corporate teams and is designed to stop programmers from hurting themselves (or stepping onto someone else’s turf). “Bureaucratic” is perhaps the best way to describe the language. If you take out private from a language like that, you lose most of its raison d’etre. So is private a good thing? Probably not. Does it need to stay in Java? Probably.

I’d like to reiterate that I think that message-passing is a superior way to think about object-orientation and it makes the public/private debate unnecessary. That’s why the language I’m building for my thesis will have message-passing. I’m also stealing Ruby’s private-by-default and metaprogramming for accessors.

The James Franco Project This has nothing to do with computers, technology or programming. James Franco is an actor who is leading a very full life — he’s acting full time (on multiple projects) while working on multiple graduate degrees at different places around the country. Certainly not something that’s recommended for everyone, but it goes to show just how much one man can do if he puts his mind to it.

Media

Dieter Rams – More is Less The design of technological objects has always fascinated me and Jonathan Ives might be the design man of the current times, but this video shows off Dieter Rams’ work and some of his key insights and you can see them reflected in the modern gadgets that we consider to be attractive.

Software

Foursquare I’ve just recently started using Foursquare (yes, I know after Facebook announced places) which is an iPhone, Android and Blackberry app that lets you “check-in” to places you visit and gather points for traveling and visiting. It’s a fun little utility and makes for interesting games with friends (and probably helps generated revenue for local businesses). I’m hesitant to say if it’s actually useful, but it’s definitely worth trying out.

Note: I find that I’m starting to explore less and less and am considering retiring the software section in upcoming weeks. Let me know if you have any suggestions.

Reading

The early history of HTML Have you ever wondered how the great World Wide Web came to be? Apparently it’s a bit of a mystery but this article does a good job of piecing things together and giving some insight into how HTML.

What happened to Yahoo! Even though Yahoo still exists and owns some really great websites (like Delicious and Flickr), it seems to have completely dropped off the map in recent years. Paul Graham (whose startup was bought by Yahoo!) takes a look at why Yahoo! seems to have lost its relevance.

Media

Twilio on NY Tech Meetup It’s not that often you see people writing code live during presentations, so when you do see people whipping up live code to create usable webapps and then opening them up to the public, that’s something really worth watching.

Software

Instapaper aims to bring back the practice of reading long-form pieces of the Internet. It lets you save webpages and also helpfully extracts the text from the page. There are iPhone, iPad and Kindle apps to help you read anywhere and anytime.

This is the first time that I’m making my own language, but I have been studying programming languages for the last 2 to 3 years. And I want to take those lessons learned and apply them. I’m trying to strike a balance between taking the best of what’s out there and putting in original ideas. There are a lot of great ideas out there but they’re spread across lots of different languages. Some languages like Ruby do a great job of pulling together the best of what’s out there. Under normal circumstances I would be perfectly happy with building a language that does nothing new. But this is an academic honors thesis and I would be really really disappointed with myself if I didn’t contribute anything new.

What am I going to do that’s new? I want to solve a problem that is actually being faced by programmers on the front line and though I admire the theory behind languages, I’m more interested in implementation than pure theory. One clear problem in our field is the rise of slower, parallel processors, multicore CPUs in particular. And we have very little idea of how to use all those cores probably. There are certainly solutions that are being proposed — threads, software transactional memory, Actors, so on and so forth. But these tools are generally considered beyond the reach of everyday programmers. What most programmers are acquainted with is object-oriented programming. My idea is to take an object oriented language and make it concurrent from the bottom up. The naive idea (that I have to significantly research and refine) is that each object is its own thread of operation. This is similar to the Actor model and I’ll need to study and think more to see how to differentiate between that and what I want to do.

But as I said there are a lot of good languages out there with great ideas and I’m going to shamelessly take as many of them as I can. Everything will be an object, but it will be prototype-based (a la JavaScript), not class-based. Syntax-wise it will be elegant and homoiconic: that is there will be as few special syntactical constructs as possible and programs will be data structures in the language itself. This is to lay the groundwork for macros, though I probably won’t be getting to that any time soon. However, it will have first class functions from day one and I’m going to try like hell to make everything (or make it possible to make everything) first-class. And this isn’t just for functions, I want to extend it to tests, constructs and even documentation. All of these are good ideas that have been tried and tested before, I’m just combining them in a new (and hopefully better) way.

Technology aside, the language will be completely open source, probably under the GPL v3. As for the name, I’m probably going to call it Parley. I want a name that implies discussion. Plus it opens up a whole world of pirate-related metaphors and names for later use and I love word-play. I don’t plan on really working on it until the end of August, though I will be reading up and throwing ideas around. Code will be on Github as soon as I have something that works.

Emacs vs Vi is rooted in the love of Lisp — This is an older article I came across a few days which shows how the universal programming powers that define Lisp are at the root of the Emacs/Vi divide

Have generics killed Java in which the authors argues that generics have harmed Java and that static type checking is a dead-end

Media

Public Static Void — an excellent talk by Rob Pike that discusses language and evolution and why our languages mostly suck

Software

Firefox Alpha with TabCandy is an early test release that contains a very interesting new interaction interface for tabs which I think is a step forward. Now if only I could run it all from my keyboard. Be warned that no extensions will work.

Bonus: Here’s the TabCandy video

The ByteBaker by Shrutarshi Basu is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
Permissions beyond the scope of this license may be available at http://bytebaker.com/contact.

This is something I should have done a long long time ago. But as they say, better late than never. I received an email yesterday from Robert Sebescen at Kodknackaren.se offered to translate and host the posts from the Powerful Python series. I was going to say yes and then realized that though I didn’t have any sort of licensing information on The ByteBaker.

So today I’m changing that. All the content that I’ve written on the site is under the Creative Commons license as stated above. It basically means that you can redistribute my work and create derivative works from it (such as Sebescen’s translations) as long as you give me due credit. However, if you are not allowed to use the work for any commercial purposes (ie, you can’t sell it or charge people to see it). I’m not again people making money, I just don’t want them doing it off of my work without giving me a cut. I have contact info on this site, so if anyone’s interested, drop me a line and we’ll talk.

I do reverse the right to change the license in the future, however I can’t see myself doing that anytime in the near future. For readers, this isn’t really a change at all. But the great thing about computers and the Internet is that it promotes an incredibly diverse and productive remix culture. And I want to my part to give back to that remix culture that has given me so much cool stuff.

Powerful Python was a series of posts about the Python programming languages and how its features make it easier for programmers to write code. As it stands now there are four posts in this series:

• A guide to Python namespaces
• Switch-case statement in Python
• Python properties vs Java Access Specifiers
• Switch-case statement in Python revisited

Python is the language that I’m most familiar with and have written the most code in. Over the last month or so I’ve been writing Python day in day out and really exercising my Python chops (as well as getting acquainted with features like generators and decorators).  Over the next few weeks I’m going to be writing more posts exploring Python and adding them to the Powerful Python series. If you regularly write code in Python or just have a passing interest, this is something you’re going to like.

The second series that I had was Sunday Selections. I try to post two to three times a week, but I didn’t want to leave the weekends completely bare. I also wanted to spend my weekends doing other things (preferably away from the computer). So I started a series where every Sunday I would post links (with brief intros) to interesting things that I had found the week before. I’ll admit that I haven’t been very stable with the post schedule, partly because I kept forgetting or losing what I had found and really didn’t want to go hunting around the intertubes for whatever it is that I liked.

Over the past few months I’ve become much better at holding onto things I find online. Using Diigo for bookmarks and Tumblr for “scrapbooking” the web I’ve been managing to keep a good record of all the wonderful stuff I’ve found (and there is a lot of it). So I’m bringing back Sunday Selections as well (starting this Sunday) so stay tuned for a steady flow of Internet-y goodness.

I’m really looking forward to writing series posts again. I feel like my writing can sometimes get either monotonous or spread all over the place without any focus. I’m hoping that the series (especially the Powerful Python series) will provide a good path for me to write articles that are coherent and progress along a definite line. Stay tuned.

Without dropping any spoilers here’s what you need to know about the movie for the rest of the article: it’s about people who go into other people’s dreams in order to steal their secrets. Pretty simple, right? The kicker is that it’s possible to dream inside another dream leading to all sorts of interesting situations and plot twists. Ok, so that’s not quite recursion since that would mean that the subject would be dreaming the same dream inside the dream (confused yet?). Come to think of it the dreams of Inception are more like closures.

So what are closures? Wikipedia tells us that:

In computer science, a closure is a first-class function with free variables that are bound in the lexical environment.

Perfectly understandable, right? No? Ok let’s translate. First and foremost, a closure is a function. But it’s not just any old run-of-the-mill function. A closure generally contains variables that are neither local variables nor arguments to that function. So what do those variables refer to? Their values come from outside the function, specifically the code block that surrounds the function. The wikipedia page on closures gives examples in a number of languages. Though closures aren’t necessarily a part of a standard curriculum they are extremely powerful constructs that can be used to implement a host of other programming language features (including control flow structures and object systems). Coming back to Inception, once you are inside a dream you can recall the world outside (though the real world seems like a dream so everything’s a bit fuzzy).

Closures in computer science (and dreams in Inception) are important because they are a prime example of abstraction. Functions are a powerful concept because they essentially let you create little worlds in which you can do stuff. You put something in a function and get something out. You don’t need to know or care about what’s going on inside the function (unless something goes wrong, but that’s a different matter entirely). Functions let you abstract away processes. Closures improve upon functions and let you abstract state. If you’re using a function that’s a closure, you don’t need to know about what it’s variables are bound to (except the ones you pass in) and you can’t see what data the closure can manipulate either.

By tucking away state, closures give us less to hold in our minds and make it easier to write code that’s clean and follows the Single Responsibility Principle (essentially, do one thing and do it well). Suppose you have a bunch of closures inside one larger function. Now magically you have sections of executable code that all operates on the same data and yet can do completely different things. They can also do all this without having to passing in a host of arguments every time (which reduces the chance for making mistakes). Whenever the closures need something, they just refer to their outer environment. Sound familiar? It should because I just described objects and methods. And that is the hallmark of a good abstraction — it lets you build up other abstractions on top.

Abstractions are in general a good thing. But unless you think through your abstractions, they can be bad. A leaky abstraction is one that doesn’t quite get it right. The underlying layers somehow “leak through” what should be the abstraction’s water tight boundaries. Joel Spolsky has a very good article on leaky abstraction that’s a must read if you want to learn more. And while we’re on the topic of abstraction — too much can be a bad thing. I wrote a Python program two summers ago to experiment with L-systems. Last summer I tried rewriting it such that everything in the system was the instance of some class. Everything was supposed to go through methods and abstraction boundaries. I never finished. This summer I toned it down a little and got a working version in about a week. Yes, this is classic second system effect, but it also shows that sometimes abstractions will just get in the way and force you to jump through hoops.

In conclusion: abstractions are good if used wisely. Closures are one such powerful abstraction. Dream safe.

There are significant parts missing. The unit testing is very, very scant. There is almost no error handling. The previous version had a GUI which I need to port to the new API/architecture. I also want to write one more interaction mode as a proof of concept that it can support multiple, different modes. The documentation needs to be converted to HTML mode and there are some utility functions that would be helpful to have. In short, there’s a lot that needs to be done. So my question is, what version of my code is this?

I started a rewrite of this last  summer as well but never finished — a casualty classic second system effect. For a while I considered calling this version 3.0 counting the unfinished copy as 2.0. But I decided it was rather silly and so I’ve actually called it 2.0. Though it’s certainly a major major change from the last version, in some ways it’s still broken and unfinished. Is it a beta? Or a release candidate? I suppose that’s a better description. Except the additions that I want to make are more than moving it from a beta to a full release. The GUI would definitely be a point release.

In many ways the debate is purely academic and kinda pointless. As I’ve written before, software is always beta. However, releasing major and minor “versions” of software is a popular activity. In some ways it’s helpful to the user. You can tell when something’s changed significantly and when you need to upgrade. In an age where you had to physically sell software, that was a good thing to know. However, the rise of web-based software has changed that to a large extent. If you’ve been using Gmail for a while, you’ll know that it has a history of small, regular atomic improvements over time. And it’s not just Gmail, it’s most of Google’s online services. Sometimes there are major facelifts (like Google Reader a few years ago) but by and large this gradual improvement works well. Google Chrome also uses this model. Chrome is officially past version 5 now. But thanks to its built in auto update mechanism you don’t need to care (and I suspect most people don’t). Rolling releases are clearly acceptable and may just be the way software updates are going to go in the future. Of course, if you’re charging for your code you’re going to have some sort of paywall, so no, manual software updates probably won’t go away forever.

Coming back to my original question, what version did I just release? 2.0? 2.0 beta 1? 1.9.5? Honestly I don’t really care. Part of my disinterest stems from the fact that Git makes branching and merging so easy. It’s hard to care about version numbers and releases when your code is in the hands of a system that makes it so easy to spin off feature branches and then merge them back in when they’re ready. If I worked in a fully Git based team I’d just have everyone running daily merges so that everyone just automatically got the new features. In that case I wouldn’t have waited to release. The big new feature would have been pushed a week ago, the reorganization and cleanup after that and then the documentation yesterday. I’d also be sending out the later updates and addition one at a time once they were done. Everyone else uses SVN, there might still be a way to do it.

In conclusion: rolling releases are awesome. Users don’t have to worry about manually updating and automagically get new features when they’re available. Developers using a good version control system can be up-to-date with everyone else’s code. This is especially important if you’re writing developer tools (which I am): the faster and easier you can get your updates to the people making the end product the faster the end product gets developed.

PS. If you’re wondering what exactly it is I’m making, more on that later. There’s a possibility of a source release after I talk to my professor about it.

The first was about Microsoft and the recent Kin debacle. It’s a good article with lots of remarks from people inside Microsoft and it’s definitely worth a read if you’re interested in technology or business at all. The article paints a pretty grim picture of where Microsoft is going. MS is definitely not my favorite technology company (and I’ve been Windows free for a while now) but it still hurts a little to see a once-great company go so tragically wrong. As I was reading that article I kept thinking that Microsoft really needed a cold, hard reboot. A complete restructuring where they would identify their core strengths (Windows and Office), unify their various disparate projects (Mobile/Kin, all their various web efforts) and bring more developers onto their side (C#, F# and the rest of .NET). Is any of this going to happen? I don’t know. I hope so, but my gut says no, sadly.

However, when I read this next article (about weak AI applied to cars and massive data sets) one line stuck out that pretty much summed up what I thought about Microsoft and its current situation. The line was this: It turns out that, innovation, like freedom, “is just another word for having nothing left to lose.” Very fitting, yes?

I think what everyone is feeling that Microsoft is simply far too big and unwieldy to make the drastic changes that are really necessary for it to stay in the game against the likes of Apple and Google. Restructuring a large company to fend off faster moving rivals is never an easy thing to do and it’s even harder when:

1. You’re company is violently divided politically into jealous corporate fiefdoms
2. Everyone in the world seems to know about how bad it is

The feeling that I think is prevalent is that even though Microsoft desperately needs to make an about turn in a lot of different areas, they’re not going to. Not yet, not unless more heads have rolled and not until they’ve lost a lot more, both in terms of interesting products and shareholder value. In other words, Microsoft will have to be forced into a situation where they have nothing left to lose before they start to really make the changes that they need to.

And that is sad. Sure, I’ve bashed Microsoft before and I’m certainly not a fan of Windows, but I too want them to get their act together and become a formidable software company again. I have good friends working at Microsoft who have had good experiences and I’ve heard good things about C# and .NET (language geek that I am). If nothing else, diversity is good and the more sources of interesting technology we have, the better. So I wish Microsoft the best of luck and really, really hope that the Kin (and Courier before it) are what finally kick Microsoft into action and push themselves to get back to the top of the game. Will that actually happen? We’ll see.