Ano ang college org niyo? And if you do have one, nararamdaman niyo ba? May seminar ba o wala lang?

May narinig ako na may nagbabalak magtayo ng computer org kaso meron na yata existing na org (meron palang org ang CS at IT, DI NAMIN RAMDAM), after reading their proposal and after learning about their proposed projects, I said WOW sana maaprubahan.

But if the admins still see it fit that they should just content themselves with the CES (FYI, CES is an acronym for Computer Explorers Society, hahaha parang high school club lang), kahit na di maramdaman ang presence nila.

run linux!

Nih pengalaman saat trouble shooting laptop teman yang pake OS Windows Vista Ultimate. Setelah saya cek ternyata proses explorer.exe gagal diload saat start up. Hal ini bisa disebabkan karena virus atau sistem yang crash. Ciri-ciriya adalah saat komputer dinyalakan, sistem operasi berhasil booting namun tidak berhasil login melalui user yang ada. Pada layar hanya nampak pointer mouse. Untuk bisa login user harus menekan ctrl+alt+delete untuk menampilkan Task Manager dan kemudian menjalankan secara manual explorer.exe tiap kali login.
Hal ini tentunya akan sangat merepotkan user, karena setiap kali login harus menjalankan explorer.exe secara manual melalui task manager.
Salah satu cara yang bisa digunakan adalah ketika kita berhasil login, kita masuk ke Registry Editor. Masuk ke
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon
Cari Subkey Shell, dan edit value datanya menjadi explorer.exe saja, tanpa ada tambahan yang lain.
Selamat mencoba dan semoga sukses!!

There are so many reasons I dislike JavaScript, I can’t hope to go into all of them.  But I’ll try to address the high-level ones here.  These criticisms are meant to address client-side web programming.  I realize there are excuses for why a lot of these things exist, but that doesn’t mean they should persist in a modern Web environment.  I think, with the exception of some Mozilla engineers (Mozilla is responsible for maintaining the language), most Web developers agree that JavaScript is horribly flawed.

In the interests of full disclosure, I am not a Web developer.  I thought about getting into it, but when I saw how horrifying JavaScript is, I backed away quickly.  But the opinions expressed below are very common in the Web developer community.

Not Strongly Typed

“Dynamically typed” languages are a bad idea.  They’re not dynamically typed, they’re “unityped.”  As Pastor Bob Harper says, you’re fetishizing one particular type to the detriment of all the others.  When you’re writing dynamically-typed code, you still have to worry about the type of things – you just have to worry about it at a much lower granularity – whether something implements function X instead of whether it’s a number.  I don’t understand why people think dynamic typing is more convenient; in particular, you have to give up type safety for it, the lack of which causes a whole new class of problems called “runtime type errors.”  JavaScript’s problems with typing show up in its almost-but-not-quite-the-same objects, ie. “primitive strings” vs. “string objects.”

For a language like JavaScript, where efficiency is so important, not using a strong typing system is unforgivable.

Writing Efficient JS Code Requires Massive Inside Knowledge

I found Dmitriy Baranovskiy’s post on “bloopers” in Google’s Closure library indispensible for this section.

Looping

The following loops all do the same thing, but all have very different runtimes:

for (var i = fromIndex; i < arr.length; i++) {
  ...blah...
}

for (var i = fromIndex, ii = arr.length; i < ii; i++) {
  ...blah...
}
var i = arr.length;
while (i--) {
  ...blah...
}

The third runs faster than the second, which runs faster than the first.  Is there a justifiable reason for making the language perform differently for these different looping constructs?  One might suggest that, in the first loop, you might want to iterate over an array with changing length.  In that case, you aren’t really iterating over the array, you’re using some other metaphor, and shouldn’t be in a for loop.

Object.prototype

You’re allowed to add things to Object.prototype.  But doing so will break not only your own code, but everybody else in the world’s code as well.  This is one of the beautiful flaws with object prototyping.

String Conversion

Why is

var replacement = String(arguments[i]).replace(…);

slower than

var replacement = (arguments[i] + "").replace(…);

?

Weird Idiosyncracies

Automatic Semicolon Insertion

The rules for when JavaScript will automatically insert semicolons are basically “We automatically put in semicolons if the statement would be illegal without it.”  The problem is, this is impossible to predict in practice (except for JS gurus, of course).  It’s a very common source of bugs in JS.  Why is this feature in here?

When is JavaScript code loaded?

It depends on where in the HTML file the JavaScript code is referenced (or whether it’s loaded dynamically in the JavaScript).  Thus, you need to spread your JS throughout your HTML document to get desired behavior (usually).

Browser compatibility

It’s a shame that you need to write different code for different browsers, but to JS’s credit the (basically mandatory) third-party libraries tend to let you gloss over this.  Which reminds me…

Mandatory Third-Party Libraries

It’s impossible to write useful JS code without using a third-party library like jQuery or Closure that provides all the features missing from the core language (which must then be included in every web page that uses it).  Of course, this is a criticism you can level at a lot of languages.

Towards a Solution

The problem is, if JS weren’t so entrenched in our browsers, something better would’ve supplanted it a long time ago.  Combating this entrenchment will be a real problem for any web language hopeful.

I think we should look at JavaScript as more like assembly language than any real modern programming language.  For example, JavaScript is one of the very few languages where the size of your source code matters.  Today, it’s very important to “compile” your JavaScript with a minimizer for production.  However, it’s not mandatory – and it should be.  Once you’ve got a compilation step in, why bother writing JavaScript at all?  This is the approach Google has taken with their Google Web Toolkit.

I think this is the right approach.  A first step would be a Language X to JavaScript compiler (some possible Language X’s: Java (GWT), OCaml, or Haskell (YHC)).  Web developers could then write in a high-level, safe language without worrying about all the crap JavaScript makes you deal with.  You’d also get minimized, efficient code as a result (without worrying what kind of loop construct to use, for example).

The next step would be for browser makers to recognize that supporting Language X natively would be a big performance increase.  Then we’d have a hybrid Web, where some pages are in JavaScript (old-style of compiled-from-X) and others will detect that you’re capable of reading Language X directly and just send you that.  A browser plugin would be a great intermediary between these two steps.

Finally, one day we could eventually see JavaScript phased out altogether.

TSTC Publishing staff members enjoy working with all the interns. Earlier posts introduced TSTC and Baylor interns. This posting introduces you to Andres Torres and Laina Juarez, our workstudy interns.Andres Torres is a computer science technology major from Grand Prairie, Texas. As a work study intern, Andres works with everyone on the publishing team, assisting with special projects. Andres is now well-experienced in the Highrise program, He describes his level of expertise as “just below a Jedi.” Andres said he chose TSTC because it will help him reach his ultimate goal to program for a big company. In the future, Andres sees himself working for Microsoft or Blizzard.

When he gets a little free time, Andres likes to play sports, video or computer games, and indulge in his love for science fiction. Andres loves the adventures of science fiction because he likes to imagine himself as the character, and being a part of “all of the amazing stuff that happens on the adventures.”

Arlington native Laina Juarez works as a data entry intern at TSTC Publishing. Laina is a computer science major. She hopes to work as a database administrator. “My dad is a database administrator and has the flexibility of working at home,” said Laina.

Originally furthering her education at Ball State University in Indiana, Laina transferred back to Texas after her freshman year, and began studying computer science at TSTC Waco. She said she thought would be more advantageous to have a two-year degree in computer science than a four-year degree in psychology, so she made the move to TSTC.

When Laina isn’t studying or working, she enjoys reading the “Twilight” saga and “Great and Terrible Beauty.” She also enjoys playing pool at Clicks.

Although she hasn’t planned her future completely, Laina knows she wants to stay in Texas. She has family in Florida, and “it snows too much in Indiana,” she said. Laina plans to graduate with a degree in computer science in the summer or fall of 2010.

Kristin and Alyssa

Click Here to Subscribe to Our Blog Posts by Email

Berikut ini adalah source code sederhana untuk enkripsi RC4. Source code ini dibuat menggunakan bahasa pemrograman Java.


import java.io.*;
//import java.lang.Character;
/**
*
* @author zlich
*/
public class RC4 {
public static void main (String [] args) throws IOException {
int [] key = null;
int keylen = 0;
int k = 0;
int [] SBox = new int [256];

//XOR
int chiper = pseudo ^ chartext;
System.out.print(Integer.toHexString(chiper).toUpperCase()); //chipertext
//System.out.print(Character.toChars(chiper));
}
}
}


Source codenya masih menggunakan prosedural, untuk pendekatan OOP sedang diusahakan.

Kalau dicompile terus dieksekusi outputnya kayak gini:
Key:
pwd12
112 119 100 49 50
Plaintext:
Math 310 Proves!
6CA86FE3CBC33C162595C3E78B9C97BC


Selamat Mencoba!!

Once again, I return to the technique of using a metaphor created by a recent South Park episode (Season 13, Episode 10) to illustrate the way things are (in an entirely different subject). Warning: There is adult, offensive language in the video clips I use below. My usual admonition applies. If you are easily offended, please skip them.

The episode is about the popular perception of wrestling, promoted by the WWF, vs. the real sport. It uses the same theme as an earlier episode I used, which satirized Guitar Hero: The pop culture is taking something which involves discipline and hard work, with some redeeming quality, and turning it into something else entirely with no redeemable value. Rather than challenging us to be something more, it revels in what we are.

This is a follow-up post to “Does computer science have a future?” It fleshes out the challenge of trying to promote a real science in computing…with some satire.

I’ve been getting more exposure to the evolution of CS in universities, which extends to the issue of propping up CS in our high schools (which often just means AP CS), though there’s been some talk of trying to get it into a K-12 framework.

University CS programs have been hurting badly since the dot-com crash of 2001. Enrollments in CS dropped off dramatically to levels not seen since the 1970s. We’re talking about the days when mainframes and minicomputers seemed to be the only options. It’s not too much of a stretch to say that we’ve returned to that configuration of mainframes and terminals, and the thinking that “the world needs only 5 computers”.

After looking at the arc of the history of computing over the last 30 years, one could be excused for thinking that an open network like the internet and an open platform like the personal computer were all just a “bad trip”, and that things have been brought back to a sense of reasonable sobriety. This hides a deeper issue: Who is going to understand computing enough to deal with it competently? Can our universities orient themselves to bring students who have been raised in an environment of the web, video game consoles, iPods, and smart phones–who have their own ideas about what computers are–to an understanding of what computing is, so they can carry technological development forward?

Going even deeper, can our universities bring themselves to understand the implications of computing for their own outlook on the world, and convey that to their students? I ask this last question partly because of my own experience with computing and how it has allowed me to think and perceive. I also ask it because Alan Kay has brought it up several times as an epistemological subject that he’d like to see schools ponder, and in some way impart to students: thinking about systems in general, not just in computers.

The point of the internet was to create a platform upon which networks could be built, so they could be used and experimented with. It wasn’t just built so that people could publish porn, opinion, news, music, and video, and so that e-commerce, information transfer, chat, and internet gaming could take place.

The personal computer was not just created so that we could run apps. on it, and use it like a terminal. It was created with the intent of making a new medium, one where ideas could be exchanged and transactions could take place, to be sure, but also so that people could mold it into their own creation if they wanted. People could become authors with it, just as with pen, paper, and the typewriter, but in a much different sense.

But, back to where we are now…

Most high schools across the country have dropped programming courses completely, or they’re just hanging on by a thread (and in those cases an AP course is usually all that’s left). The only courses in computer literacy most schools have offered in the last several years are in how to use Microsoft Word and Excel (and maybe how to write scripts in Office using VBA), and how to use the web, Google, and e-mail.

CS departments in universities are desperate to find something that gives them relevance again, and there’s a sense of “adapt or die”. I’ve had some conversations with several computing educators at the university and high school level about my own emerging perspective on CS, which is largely based on the material that Alan Kay and Chris Crawford have put forward. I’ve gotten the ear of some of them, but only a rare few seem to have the background and open mindedness to understand and consider what I have to say. These few like entertaining the ideas for a bit, but then forget about it, because they don’t translate into their notions of productive classroom activities (implementations). I must admit I don’t have much of a clue about how to translate these ideas into classroom activities yet, either, much less how to sell them to curriculum committees. I’m just discovering this stuff as I go. I guess I thought that by putting the ideas out there, along with a few other like-minded people, that at least a few teachers would catch on, become inspired, and start really thinking about translating them into curriculum and activities.

I’ve been getting a fair sense from afar about how hard it is for computing educators to even think about doing this. I’ve been surprised, because I’ve always thought that it’s the teachers who come up with the curriculum, and in this “time of crisis” for CS they would be interested in a new perspective. It’s actually an old perspective, but it hasn’t been implemented successfully on a wide scale yet, and it’s a more advanced perspective than what has been taught in CS in most places for decades.

The challenge is understandable to me now at one level, because any alternative point of view on CS, even the ones currently being taught in some innovative university programs, run into the buzz saw of the pre-existing student perspective on computing (prepare, there’s an analogy coming):

Trying to teach anything akin to “the real thing” (using computing in deep and creative ways to create representations of our ideas and test them, and possibly learn something new in the process) tends to get weird looks from students (though not from all):

There’s a temptation on the part of some to take away from this experience the idea that the material they’re presenting is no longer relevant, and that the students’ perspectives should be folded into what’s taught. I agree with this up to a point. I think that the presentation of the material can be altered to help students better relate to the subject, but I draw the line at watering down the end goal. I think that subjects have their own intrinsic worth. Rather than trying to find a way to help more students pass by throwing out subjects that seem too difficult, there should instead be remedial support that helps willing students rise up to a level where they can understand the material. To me, the whole idea of a university education is to get students to think and perceive at a more sophisticated level than when they came in. CS should be no different. You’d be surprised, though, how many CS professors think the more important goal is to teach only about existing technology and methodologies.

Talking to most other CS educators at the high school and university level has been an eye-opening and disheartening experience, because we get our terminology confused. I mean to say one thing, and to my amazement I get people who honestly think I’m saying the complete opposite. In other cases we have a different understanding of the same subject, and so the terms we use get assigned different meanings, and I come to a point where I realize we can’t understand each other. The background material for where we’re coming from is just too different.

Many CS professors (whom I have not met, though I’ve been hearing about them) apparently think all of this “real thing” stuff is quaint, but they have real work to do, like “training IT professionals for the 21st century”. Phah! Guess what, people. Java is the new Cobol (in lieu of Fortran, no less…). Web apps. are the new IBM 3270 apps. Remember those days? Welcome to the 1970s! And by the way, isn’t CS starting to look like CIS? Just an observation…

(A little background on the clip below: In the story, after the failed attempt at learning real wrestling (in the clip above), the South Park kids form their own “wrestling show”, which is just play acting with violence, complete with the same scandal-ridden themes of the “WWE wrestling” they admire so much. A bunch of “redneck” adults in South Park gather around to watch in rapt attention.)

Note I am not trying to call anyone “stupid” (the wrestling teacher in South Park has a penchant for calling people that), though I share in the character’s frustration with people who are unwilling to challenge their own assumptions.

I get a sense that with many CS professors the bottom line is it’s all about supporting the standard curriculum in order to turn out what they believe are trained IT professionals who are capable of working with existing technology to create solutions employers need. I wonder if they’ve talked to any software developers who work out in the field. I’m sure they’d get an earful about how CS graduates tend to not be of high quality anymore.

The faculty support their departmental goals and the existing educational field. The belief is, ”Dammit! We’ve gotta have something called ‘CS’, because something is better than nothing.” This ends up meaning that they accommodate the dominant perspective that students have on computing. This ultimately goes back to the dominant industry vision, which now has nothing to do with CS.

When I’ve found a receptive CS professor, what I’ve suggested as a remedy, along with “moving the needle” back to something resembling a real science, is that the CS community needs to invent educational tools: Their own educational artifacts, and their own programming languages. This still goes on, though it’s not happening nearly as much as it did 40 years ago. I think that the perspectives of students need to be taken into consideration. The models used for teaching need to create a bridge between how they think of computing coming in, and where the CS discipline can take them.

The standard languages that most CS departments have been using for the past 14 years or so are C++, and now Java. C++ came from Bell Labs. Java came from Sun Microsystems. Both were created for industrial use by professionals, not people who’ve never programmed a computer before in their lives! In addition, they’re not that great for doing “real CS”. I’ve only heard of Scheme being recommended for that (along with some select course material, of course). I haven’t worked with it, but Python seems to get recommended from time to time by innovative people in CS. It’s now used in the introductory CS course at MIT. My point is, though, there needs to be more of an effort put into things like this in the CS academic community.

What’s at stake

In my previous post I link to above I asked the question, which Alan Kay asked in his presentation, “Does CS have a future?” I kind of punted, giving a general answer that’s characterized the field through the last several decades. I figured it would continue to be the case. This is going to sound real silly, but this next scene in South Park actually helped me see what Kay was talking about: We could lose it all! The strand that spans the gulf between ignorance and “the real thing” (a connection which is already extremely tenuous) could snap, and CS would be all but dead:

What came to mind is that it wouldn’t necessarily mean that the programs called “CS” would be dead, but what they teach would end up being something so different and shallow as to not even resemble the traditional CS curriculum that’s existed for 30+ years.

What I’ve learned is there’s a lot of resistance to bringing a more powerful form of CS into universities and our school system. This is not only coming from the academics. It’s also coming from the students. This is because, ironically, it’s seen as weak and irrelevant. I’ve already given you a feel for where the student perspective is at. Alan Kay identified a reason why most CS academics don’t go for it: They think what they’re teaching is it! They think they’re teaching “real CS”. They have little to no knowledge of the innovative CS that was done in the 1960s and 70s. They couldn’t even recall it if they tried, because they never studied it. They’re historically illiterate, just like our industry.

High school “CS” teachers (why not just call their courses “programming”. That’s what they used to be called) are hapless followers of the university system. They’re less educated than the CS professors about what they do. From what I’ve heard about the standards committees that govern curriculum for the public schools, they’d have no clue about what “real CS” is if it was shown to them. This isn’t so much a gripe of mine as an acknowledgment that the public schools are not designed for teaching the different modes of thought that have been invented through the ages. There’s no point in complaining about a design, except to identify that it’s flawed, and why. The answer is to redesign the system and then criticize it if the intent of the design is not being met.

My sense of the historical ignorance in our field, having been a part of it since I was a teenager, is people take it as an article of faith that there’s been a linear progression of technological improvement. So why look at the old artifacts? They’re old and they’re obviously worse than what we have now. That’s the thinking. They don’t have to verify this notion. They know it in their bones. If they’re exposed to technical details of some of the amazing artifacts of the past, they’ll find fault with the design (from their context). How the design came about is not seen as valuable in and of itself. Only the usefulness that can be derived from it is seen as worthy. Most CS academics are not too distant from this level of ignorance. I get a sense that this comes from their own sense of inadequacy. They know they couldn’t design something like it. They wouldn’t expect themselves to. As far as they’re concerned electrical engineers and programming “gods” created that stuff. They also tend to not have the first clue about the context in which it was designed. They’ll pick out some subsystem that’s antiquated by what’s used now and throw the baby out with the bathwater, calling the whole thing worthless, or at best an antique that should be displayed dead in a museum. You may get the concession out of them that it was useful as a prototype for its time, but what’s the point in studying it now? The very idea of understanding the context for the design is an alien thought to them.

The designs of these old systems weren’t perfect. They were always expected to be works in progress. What gets missed is the sheer magnitude of the improvement that occurred, the leaps in thinking about computing’s potential, and what these new perspectives allowed the researchers to think about in terms of improving their designs, the quality of which were orders of magnitude greater than what came before them (that point is often missed in modern analysis). Technologists often have the mindset of, “What can this technology do for me now?” They take for granted what they have, as in, “Now that I know how to use and do this, that old thing over there is ancient! My god. Why do you think that thing is so amazing?”

Another thing I’ve seen people dismiss is the idea that the people who created those amazing artifacts had an outlook that’s any different from their own, except for the fact that they were probably “artists”. That’s a polite way of dismissing what they did. Since they were so unique and “out there”, many of their ideas can be safely ignored, rather like how many in the open source community politely dismiss the ideas of the Free Software Foundation, and Richard Stallman. The stance is basically, “Thanks, but no thanks.” Yes, they came up with some significant new ideas, but it’s only useful to study them insofar as some of their ideas helped expand the marketability of technology. Their other ideas are too esoteric to matter. In fact we secretly think they’re a little nuts.

As I have written about on this blog, I share Kay’s view that computing has great historical and societal significance. What I’ve come to realize is that most CS academics don’t share that view. Sure, they think computing is significant, but only in terms of doing things faster than we once did, and in allowing people to communicate and work more efficiently at vast distances. The reasons are not as simple as a closed-mindedness. Kay probably nailed this: Their outlook is limited.

What it comes down to is most computer science academics are not scientists in any way, shape, or form. They’re not curious about their field of work. They’re not interested in examining their own assumptions, the way scientists do. Yet they dominate the academic field.

I’ve given some thought to some analogies for the CS major, as it exists today. One that came to mind is it’s like an English major, because the main focus seems to be on teaching students to program, and to do it well. As I’ve said before, programming in the realm of computing is just reading and writing. Where the English major excels beyond what CS teaches is there’s usually a study of some classics. This doesn’t happen in most CS curricula.

In discussions I’ve heard among CS academics, they now regard the field as an engineering discipline. That sounds correct. It fits how they perceive their mission. What generally goes unrecognized is that good engineering is backed by good science. Right now we have engineering backed by no science. All the field has are rules of thumb created from anecdotal evidence. The evidence is not closely scrutinized to see where the technique fits in other applications, or if it could be improved upon.

I am not arguing for a field that is bereft of an engineering focus. Clearly engineering is needed in computing, but without a science behind it, the engineering is poor, and will remain poor until a science is developed to support it.

My own vision of a science of computing could be described as a “science of design”, whose fundamental area of study would be architectures of computing. Lately Alan Kay has been talking about a “systems science”, which as he talked about in the presentation I link to above, includes not just architecture, but a “psychology of systems”, which I translated to mean incorporating a concept of collective “behavior” in a system of interactive systems. Perhaps that’s a shallow interpretation.

As you can tell, I now hold a dim view of traditional CS. However, I think it would be disruptive to our society to just say “let it die”. There are a lot of legacy systems around that need maintaining, and some of them are damn important to our society’s ability to function. There’s a need for knowledgeable people to do that. At the same time, Kay points ahead to the problem of increasing system complexity with poor architectural designs. It’s unsustainable. So it’s not enough to just train maintainers. Our technological society needs people who know how to design complex systems that can scale, and if nothing else, provide efficient, reliable service. That’s just a minimum. Hopefully one day our ambitions will go beyond that.

The discussion we’re not having

I happened to catch a presentation on C-SPAN last month by the National Academy of Engineering and the National Research Council on bringing engineering education into the K-12 curriculum (the meeting actually took place in September). I’m including links to the two-part presentation here, because the people involved were having the kind of discussion that I think that CS academics should be having, but they’re not. The quality of the discussion was top notch, in my opinion.

Engineering in K-12 Education, Part 1, 3 hours

Engineering in K-12 Education, Part 2, 2 hours

What was clear in this presentation, particularly in Part 2, was that the people promoting engineering in K-12 have a LOT of heavy lifting to do to achieve their goals. They are just at the infant stage right now.

Readers might be saying, “How can they possibly think of teaching engineering in primary school? What about all the other subjects they have to learn?” First of all, the organizations that held this event said that they weren’t pressing for adding on classes to the existing curriculum, because they understand that the existing school structure is already full of subjects. Rather, they wanted to try integrating engineering principles into the existing course structure, particularly in math and science. Secondly, they emphasized the engineering principles of design and systems thinking. So it didn’t sound like it would involve shoving advanced math down the throats of first graders, though teaching advanced math principles (again, principles, not drill and practice) in a fashion that young students can understand wouldn’t be such a bad idea. Perhaps that could be accomplished through such a curriculum.

I had a discussion recently with Prof. Mark Guzdial, some other CS professors, and high school teachers on his blog, related to this subject. Someone asked a similar question to what I posed above: “I agree [with what you say about a real science of computing]. But how in the world do you sell that to a K-12 education board?” I came to a similar conclusion as the NAE/NRC: Integrate CS principles wherever you can. For example, I suggested that by introducing linguistics into the English curriculum, it would then be easier to introduce concepts such as parse trees and natural language processing into it, and it would be germane. Linguistics is an epistemological subject. Computing and epistemology seem to be cousins. That was just one example I could think of.

If CS academics would actually think about what computing is for a while, and its relevance to learning, they wouldn’t have to ask someone like me these questions. I’m just a guy who got a BSCS years ago, went into IT for several years, and is now engaged in independent study to expose himself to a better form of CS in hopes of fulfilling a dream.

Universities need to be places where students actually get educated, not just “credentialed”. Even if we’re thinking about the economic prospects of the U.S., we’re fooling ourselves if we think that just by handing a student a diploma that they’re being given a bright future. Our civil and economic future is going to be built on our ability to think, perceive, and create, even if most of us don’t realize it. Our educational systems had best spend time understanding what it will take to create educated citizens.

Paul Graham wrote an article criticizing Apple for driving programmers away from their App Store.  I think I mostly agree with him.  His primary point is that, for a platform to succeed, you have to have programmers that like it and will make software for it.  Driving them away is shooting yourself in the foot.

He muses about a “killer app” for mobile phones that you could use to lure programmers away from Apple.  He suggests one such app would be a mobile phone development environment.  This sounds like an interesting problem.

The problem: Can you design a device that is small enough to use as a phone, which means you’d be willing to carry it everywhere and take calls on it and do the million other things people do on their phones these days, and yet you would also be willing to use as a development machine?

Asus EEE PC

This isn’t as far-fetched as it sounds.  I would expect most people to still have a primary development machine that has a full-size monitor and full-size keyboard.  But most programmers I know develop on their laptops when they’re on the go (on the bus, plane, or train, or out of town). I think a reasonable goal would be to make a device that programmers would feel comfortable enough using that they don’t need that laptop.  Already people are moving to netbooks to satisfy that need.

The most obvious problems are in the realm of hardware.  Would people be willing to write code on a 4″ screen?  Would they be willing to write code with a tiny keyboard?  Do phones even have enough power to compile and/or test code?

First, the screen size.  I don’t think this is as much an issue as the screen resolution, honestly.  You can fit a lot onto modern high-quality screens, provided the resolution is high enough, and the user is willing to hold it pretty close to his/her face.  Modern phones have 4″ screens with 854 x 480 resolution which is probably high enough to display a decent amount of text on at a comfortable size (I remember monitors running at 640 x 480, or even 320 x 240 ).  I think you’d have to test this to be sure, but that should be a pretty fast test.  If you’re willing to go the custom-device route, you could make something that has a foldout screen, or even a foldout secondary screen (a la the DS), at the cost of bulk.

Twiddler chorded keyboard

As for input, the keyboard on a G1 or Droid might suffice.  I don’t think an external keyboard would be the way to go; I’d have a hard time holding the phone close enough to my face to see the text, and also typing.  I’m about a hand too short.  So I think the keyboard needs to be built into the device, or have a docking station for the device.  A full-size external keyboard with a slot for the phone would be one way to go, but having to lug around a full-size keyboard, even if foldable, might be too much of a hassle.  One alternative route that I particularly like is to build a chorded keyboard into the back of the phone.  I’m picturing something with 6-12 primary buttons and some secondary buttons (like maybe a trackball), with a flip-down cover for when not in use.  For existing devices, a separate Bluetooth chorded keyboard could be used – phone in one hand, keyboard in another.  Finally, a fold-out full size keyboard might also be a solution.

One of the key pieces would be the IDE itself.  One of the keys to utilizing the small screen real estate would be a very well designed UI.  All the pieces should slide away when not in use, and be accessible quickly through the keyboard.  Good autocompletion would be required.

I personally think that most, if not all, applications should be web-based in the future.  After all, a development environment isn’t much more than a fancy text editor.  Mozilla seems to have been working on a web-based IDE called Bespin recently; the just released the text-editor portion as a developer preview.  One could imagine a remote server running Bespin (or something similar) that you just logged into from your phone; compilation (if necessary) is performed remotely, and settings are maintained between your phone and your work computer.  Other JavaScript-based text editors (that seem to be farther along) include MDK Editor and CodeMirror.

In fact, this makes me wonder why Google Code doesn’t let you edit source directly from the project page.  I imagine they’ll move in that direction soon; they look to be partway there with their Code Playground.

These are just some thoughts on how you could pull something like this off.  Would you develop from your phone if you could?