Group items tagged

A mesh object could also represent a range of cells in Excel

Live Mesh provides the building blocks to support the notion of groups, or communities (member lists) of people associated with a mesh object

The ability to open a mutually authenticated raw communications channel, to any device in a group, regardless of current location or network topology. This channel always works, by way of cloud relay if necessary, but will automatically and transparently take the cheapest and fastest possible network path.

As long as the implementation maintains the semantics guaranteed by the specification, it can choose any strategy it likes for generating efficient code

That Windows typically does so, and that this one-meg array is an efficient place to store small amounts of short-lived data is great, but it’s not a requirement that an operating system provide such a structure, or that the jitter use it. The jitter could choose to put every local “on the heap” and live with the performance cost of doing so, as long as the value type semantics were maintained

I would only be making that choice if profiling data showed that there was a large, real-world-customer-impacting performance problem directly mitigated by using value types. Absent such data, I’d always make the choice of value type vs reference type based on whether the type is semantically representing a value or semantically a reference to something.

We need to get rid of these gratuitous dependencies.  Merely papering over them with a transaction—making them “safe”—doesn’t do anything to improve the natural parallelism that a program contains.  It just ensures it doesn’t crash.  Sure, that’s plenty important, but providing programming models and patterns to eliminate the gratuitous dependencies also achieves the goal of not crashing but with the added benefit of actually improving scalability too.  Transactions have worked so well in enabling automatic parallelism in databases because the basic model itself (without transactions) already implies natural isolation among queries.  Transactions break down and scalability suffers for programs that aren’t architected in this way.  We should learn from the experience of the database community in this regard

There will always be hidden mutation of shared state inside lower level system components.  These are often called “benevolent side-effects,” thanks to Hoare, and apply to things like lazy initialization and memorization caches.  These will be done by concurrency ninjas who understand locks.  And their effects will be isolated by convention.

Even with all of this support, we’d be left with an ecosystem of libraries like the .NET Framework itself which have been built atop a fundamentally mutable and imperative system.  The path forward here is less clear to me, although having the ability to retain a mutable model within pockets of guaranteed isolation certainly makes me think the libraries are salvageable.  Thankfully, the shift will likely be very gradual, and the pieces that pose substantial problems can be rewritten in place incrementally over time.  But we need the fundamental language and type system support first.

Focus on the whole experience, meaning you need to be inclusive of display sizes, input methods, and form factors when you design and develop your applications and services.

.Net CF

expanding this functionality with QT libraries, Adobe AIR technology

StyleTap has a Palm emulator that allows you to run thousands of Palm applications on Symbian products

Red Five Labs has a runtime for Symbian OS which ensures Microsoft .net applications can be fully supported.

many people around the world are not buying and cannot afford a PC.

The Symbian Foundation is helping to do this by ensuring we lower the barrier for entry for software developers.

a good collection library should support a meta-object protocol with features like rejecting changes. This allows collections to be passed around as references,

On the Desktop - Dolphin creates 500k exe’s with ease - its a 1 button click (you just have to follow some of their easy put things in packages rules).

Remember LAN MAN? OS2? Both were heavily endorsed by Gartner.

I laugh when people say poor performance on older hardware was a mjor Smalltalk weakness. We routinely delivered applications that ran on 386 and 68020 processors with 8MB RAM. And yes, they were quite snappy. No, the reason Smalltalk didn’t catch on is because Sun spent more money on Java marketing than was spent on all computer languages combined, since the dawn of time.

I’ve listened personally to whiny ROR programmers groan and whine about PHP devs LEARNING ROR and undercutting them.

I didn’t fall for it for the marketing. I fell for WORA, for the language/runtime separation, for the multi-vendor approach (Sun never wanted to be the single provider for any Java centric product niche, and in fact was never the leader), for the comprehensive set of vendor-neutral APIs for all sorts of execution environments/applications,

For now I would like to see more use of Smalltalk like constructs in Java (Groovy).

Smalltalk must have sofisticated CASE tools, business process simulation tools, large development environments etc. etc. etc.

I stayed to teach Smalltalk since 1993 and am very happy about this information. Each academic year, we produce a small group of new Smalltalkers in the Czech Republic.

Joe Barnhart // Apr 4, 2009 at 2:48 pm At the company where I work, we have used Smalltalk for 19 years. Our tiny team of programmers has beat the pants off of competitors who employ teams 100 times our size.