As of right now (11:15 am Pacific time, Wednesday), it looks like Wall Street is putting a the best face possible on yesterday’s “correction.” (A “correction” is a Wall Street euphemism for “holy shit!”)
He also said:
The wake-up call this time was Alan Greenspan, the Oracle of Ayn Rand, whose visage had been beamed by satellite to a group in Hong Kong on Monday (New York time). Greenspan warned the gathering of excess liquidity in global financial markets, leading to over-optimism, and he predicted a recession later this year.
Boom!
Too early yet to tell how big this explosion will be.
If you read his post you’ll see he mentions China. Anything that has an impact on the chinese economy, is of immideiate interest. The reason is right before you.
After 3 weeks of using Google Reader, I can honestly say that I’m not looking back.
The App is just so damn inteligent. The other day I read a shared Doc Searls post via Robert Scoble’s link blog. Not only was the post in the Link blog marked as read. But the same post in my seperate Doc Searls feed was marked read as well. Amazing. Its these small, hardly noticable, under publicised but highly valuble features that earn an app a loyal userbase.
We’ll put up with a little less readability in order to share items with other people, in order to see the information on multiple computers and platforms, and the ability to mash up the content with content from other services ala BlogLines, NewsGator, or Google Reader or other RSS aggregators.
There is seriously very little to evern begin complaining about GoogleReader.
Perhaps integrated blogging with your own blog (they don’t even do Blogger!) in the form of a “Blog This” button. Google should seriously think about this. If they want to become the worlds [Personalised] Homepage, they can do alot more.
The only sour note, if you can call it that, are people who use partial text feeds ( forgive the mixed tenses – I’m worked up about this ). It drives me insane. Perhaps I should just unsubscribe?
The good thing about the whole Google experiance is that the page updates as if its a thick client application running localy – emails and all. I’d love to see the framework that makes it possible.
Johnathan Schwatrz, CEO of Sun Microsystems, just posted something interesting and something I’ve never thought about.
Nowdays, server-side hardware is tending to focus on unilisation rather than sheer clock speed. I guess the point is to make more use of each single clock pulse. if you have 8 cores with 32 threads executing 32 instructions per clock pulse, it beats the hell out of a single core with a single thread exectuting one instruction per clock pulse. This is known as server virtualization . Essentially because you can assign a different OS ( never mind application) to each core, effectivly getting 8 servers ( in the case of the Niagra chip) for the price one one physical server. Not that you’d find 8 server OS’s, which is beside the point. But all this fancy stuff is usually dedicated to servers ( Intel Core Duos and Quads to the contrary). And servers need to be networked. And you only have one physical network to use. Or do you:
That’s why we just introduced Project Neptune – a silicon project that marries the parallelism of the microprocessor (for Intel, AMD and SPARC systems), with the parallelism of the underlying operating system (Solaris, Linux or Windows), with parallelism in the network itself. Which in concert with some software magic (which goes by the name of the Crossbow project) allows enterprises to collapse cabling, ports, cards and spending – by bringing parallelism to basic network infrastructure (for geeks, you can take multiple TCP streams and allocate them to different processor threads, spreading out load and freeing up CPU’s/ports). Ports become a physical convenience, just like a server – what’s happening inside depends upon rules or policies set by the user/administrator to automate such decisions. Like I said, the network is the computer, and the computer’s virtualized, so why not the network?
Its simply too obvious to notice till its pointed out. For each physical port attached to your machine, you can have one physical connection. Here Sun engineers have turned that inside out, giving network engineers more bang for their buck ( or is that more connections for their ports?).
I spent a few hours syncing my BlogRoll with GoogleReader and did a little feed maintancence. So my BlogRoll is pretty much uptodate.
I also started adding items to my linkblog, provided by GoogleReader. The RSS Feed is at the top of the right hand column. It’ll contain a few items that I think are worth sharing.
Jeff Atwood has a great post on this. Its esentially about the tendency of code to get larger and larger, ad infinitum. I agree. Code can become so large that its unwiely and difficult to work with. A case in point.
I’m writing a product management system, on and off as a hobby to fill in the hours. Until a few months ago, my data strucures and my data source code were in the same class. This gave me a problem.The data sorce code was problematic meaning that it brough everything else down with it. I seperated the two ( logically) seperate enities and you wouldn’t belive how much better both class now are both to work with and to trouble shoot. So a little foward planning would have made me code smaller and better.
I think that pre-planning is part of it, but there’s only so much Big Design Up Front (BDUF) you can do. More and more, as I work on larger and larger projects (and product suites) I realize that refactoring effectively and often is as or more valuable as pre-planning.
So, simply resisting the tendancy to add sub routines, modules, classes, etc to fill the immidate need for functionality (or i my case, data) is not enough. Some sort of planning is needed, formally or not. Having a good idea of what a given sction of code needs and does not need is of paramount importance. I add the “does not need” since I often find subroutines that have long since been made obselete by a newer subroutine or requirement. It may be 5 or fifty lines of code, but unused subroutines waste time, space and can lead to confusion when reading the code ( Code is part of the documention).
Scott seems to have the same problem:
I ran this CQL query without the “TOP 10″ qualifier on some code on one project and found 292 methods that weren’t being used.
292 methods? Unused? It’ll make me feel better next time I read my code.
And it serves to highlight the point. If its not needed, get rid of it!
What precicely do we need out of a programming language? Steve Yegge has a list:
Here’s a short list of programming-language features that have become ad-hoc standards that everyone expects:
Object-literal syntax for arrays and hashes
Array slicing and other intelligent collection operators
Perl 5 compatible regular expression literals
Destructuring bind (e.g. x, y = returnTwoValues())
Function literals and first-class, non-broken closures
Standard OOP with classes, instances, interfaces, polymorphism, etc.
Visibility quantifiers (public/private/protected)
Iterators and generators
List comprehensions
Namespaces and packages
Cross-platform GUI
Operator overloading
Keyword and rest parameters
First-class parser and AST support
Static typing and duck typing
Type expressions and statically checkable semantics
Solid string and collection libraries
Strings and streams act like collections
Visual Studio missed the cross platform bit (Unless there’s a way for writing Linux readable C++ that no one has told me about).
A language is not simply a series of sematic rules that work together to produce meaningful output ( written or spoken), but also the way we think. When I speak english, I think english. When I’m speaking itallian, I think itallian.
A programming language is the same. Progammers need to be able to think in a given language and also anticipate the reaction of the complier. A well thought out subroutine, is far better than one riddled with badly, though workable, code.
Thinking in code is important. (Its also a valid reason to say your’re working). When one thinks in code, the output becomes automatic. The trick is learning your chosen language(s) thoughly enough.
Which brings me to the subject of switching languages. Do we want a new porgamming language to learn every 18-24 months? Can we even sustain that sort of learning curve?
At the end of the day, the Next Big Language (NBL as steve says) will have to be worth the effort to switch. BEcuase choosing the right programming language is crucial to programmers – if you can’t think it….
A wonderful, related, podcast here from OpenSource Conversations on Scott Rosenburg’s new book, Dreaming in Code:
I find my self tending towards using IE7 fro preciclythat reason: A native UI. While the ability to re-skin Firefox with any one of hundreds, if not thousands, 0f skins is attractive on paper, I find Firefox a bit “strange” after an extended IE7 session.
They are both the same, with near enough the same abilities and the UI differences show up for that reason. I agree with Jeff:
When two applications with rough feature parity compete, the application with the native UI will win. Every time. If you truly want to win the hearts and minds of your users, you go to the metal and take full advantage of the native UI.
But when it comes to day-to-day browsing, I’ll always pick native speed and native look and feel over the ability to install a dozen user extensions, or the ability to run on umpteen different platforms. Every single time.
Time to get The Mozilla Foundation to adopt the .Net Framework.
concert with some software magic (which goes by the name of the 
