Slashdot Mirror

InfoQ got some interesting insights from their interview with Christophe de Hauwer, the chief strategy and development officer at the communications satellite company SES: According to Morgan Stanly, the global space economy is predicted to grow from $350 billion in revenues today to more than $1.1 trillion by 2040. This impressive growth is driven by an exploding demand for connectivity... On one hand, satellite will be key to satisfy consumers' demand for always-on, high-performance connectivity. On the other hand, it will play an essential role in providing connectivity to populations in underserved and unserved areas...

[A]irlines are facing growing demands for inflight connectivity: market studies have shown that 63% of travelers think more flights should offer Wi-Fi, and 48% think Wi-Fi in the air should be as fast as it is on the ground. We are shaping and scaling our satellite fleet in order to deliver both the performance and economics needed to take these services mainstream. Whether a plane is travelling along densely populated routes or vast areas of deserts, we want to have them covered with the right kind of connectivity, always on, everywhere.
He also points out that SpaceX's re-usable rockets are just one of the ways space technology is making telecommunications cheaper.

"Electric propulsion means satellites can achieve a 40-50% reduction in their mass; high-throughput spot beams deliver a significantly higher amount of bandwidth than traditional satellites and can reduce cost per bit; fully new digitized payloads enable increased efficiency, full flexibility in global coverage and further optimization of spectrum use."

A reminder for commenters: non-commercial use of Java remains free. An anonymous reader quotes InfoWorld: Oracle has revamped its commercial support program for Java SE (Standard Edition), opting for a subscription model instead of one that has had businesses paying for a one-time perpetual license plus an annual support fee... It is required for Java SE 8, and includes support for Java SE 7. (As of January 2019, Oracle will require a subscription for businesses to continue getting updates to Java SE 8.)

The price is $25 per month per processor for servers and cloud instances, with volume discounts available. For PCs, the price starts at $2.50 per month per user, again with volume discounts. One-, two-, and three-year subscriptions are available... The previous pricing for the Java SE Advanced program cost $5,000 for a license for each server processor plus a $1,100 annual support fee per server processor, as well as $110 one-time license fee per named user and a $22 annual support fee per named user (each processor has a ten-user minimum)...

If users do not renew a subscription, they lose rights to any commercial software downloaded during the subscription. Access to Oracle Premier Support also ends. Oracle recommends that those choosing not to renew transition to OpenJDK binaries from the company, offered under the GPL, before their subscription ends. Doing so will let users keep running applications uninterrupted.
Oracle's senior director of product management stresses that the company is "working to make the Oracle JDK and OpenJDK builds from Oracle interchangeable -- targeting developers and organisations that do not want commercial support or enterprise management tools."

An anonymous reader quotes InfoQ: Ron Jeffries, author, speaker, one of the creators of Extreme Programming (XP), and a signatory of the Agile Manifesto back in 2001, shared a post on his blog in which he advocates that developers should abandon "Agile". The post further elaborated that developers should stay away from the "Faux Agile" or "Dark Agile" forms, and instead get closer to the values and principles of the Manifesto. The terms "Faux Agile" and "Dark Agile" are used by the author to give emphasis to the variety of the so-called "Agile" approaches that have contributed, according to him, to make the life of the developers worse rather than better, which is the antithesis of one of the initial ideas of the Agile Manifesto...
Jeffries writes that "When 'Agile' ideas are applied poorly, they often lead to more interference with developers, less time to do the work, higher pressure, and demands to 'go faster'. This is bad for the developers, and, ultimately, bad for the enterprise as well, because doing 'Agile' poorly will result, more often than not, in far more defects and much slower progress than could be attained. Often, good developers leave such organizations, resulting in a less effective enterprise than prior to installing 'Agile'...

"it breaks my heart to see the ideas we wrote about in the Agile Manifesto used to make developers' lives worse, instead of better. It also saddens me that the enterprise isn't getting what it could out of the deal, but my main concern is for the people doing the work..." He argues developers should instead just focus on Agile's good general software development practices -- like regularly producing fully-tested software and consciously avoiding "crufty" complex designs.

But what do Slashdot's readers think? Should developers abandon Agile?

Kesha Williams, reporting for InfoQ (shared by numerous readers): The Java Mission Control suite of tools, also known as JMC, was open sourced by Oracle on May 3rd to much applause and excitement from the Java development community. The excitement was replaced with unease as sources reported that the entire JMC development team had been laid off. JMC is a well-known profiling and diagnostics tools suite for the Java Virtual Machine (JVM) primarily targeting systems running in production. It is used by developers to gather detailed low-level information about how the JVM and the Java application are behaving. The official open source announcement came on May 5th from Marcus Hirt, a member of the Java Platform Group at Oracle. "Just wanted to say thank you to everyone who helped open source Java Mission Control in the relatively short period of time it was done in." According to Hirt, the intent behind open sourcing JMC was to provide the community with the opportunity to add new features and capabilities to the tools suite.

"I was trained more as a linguist than a computer scientist," says Perl creator Larry Wall, "and some people would say it shows." An anonymous reader describes Wall's new video interview up on InfoQ: "With a natural language, you learn it as you go," Wall says. "You're not expected to know the whole language at once. It's okay to have dialects... Natural languages evolve over time, and they don't have arbitrary limits. They naturally cover multiple paradigms. There are external influences on style... It has fractal dimensionality to it. Easy things should be easy, hard things should be possible. And, you know, if you get really good at it, you can even speak CompSci."

Wall also touched on the long delay for the release of Perl 6. "In the year 2000, we said 'Maybe it's time to break backward compatibility, just once. Maybe we can afford to do that, get off the worse-is-worse cycle, crank the thing once for a worse-is-better cycle." The development team received a whopping 361 suggestions -- and was also influenced by Paul Graham's essay on the 100-year language. "We put a lot of these ideas together and thought really hard, and came up with a whole bunch of principles in the last 15 years." Among the pithy principles: "Give the user enough rope to shoot themselves in the foot, but hide the rope in the corner," and "Encapsulate cleverness, then reuse the heck out of it.."

But Wall emphasized the flexibility and multi-paradigm nature that they finally implemented in Perl 6. "The thing we really came up with was... There really is no one true language. Not even Perl 6, because Perl 6 itself is a braid of sublanguages -- slangs for short -- and they interact with each other, and you can modify each part of the braid..."
Wall even demoed a sigil-less style, and argued that Perl 6 was everything from "expressive" and "optimizable" to "gradually-typed" and "concurrency aware," while supporting multiple virtual machines. He also notes that Perl 6 borrows powerful features from other languages, including Haskell (lazy evaluation) Smalltalk (traits), Go (promises and channels), and C# (functional reactive programming).

And towards the end of the interview Wall remembers how the original release of Perl was considered by some as a violation of the Unix philosophy of doing one thing and doing it well. "I was already on my rebellious slide into changing the world at that point."

An anonymous reader quotes InfoQ: GitHub has recently launched its Open Source Guides, a collection of resources addressing the most common scenarios and best practices for both contributors and maintainers of open source projects. The guides themselves are open source and GitHub is actively inviting developers to participate and share their stories... "Open source is complicated, especially for newcomers. Experienced contributors have learned many lessons about the best way to use, contribute to, and produce open source software. Everyone shouldn't have to learn those lessons the hard way."

Making a successful first contribution is not the exclusive focus of the guides, though, which also strives to make it easier to find users for a project, starting a new project, and building healthy open source communities. Other topics the guides dwell on are best practices, getting financial support, metrics, and legal matters.
GitHub's Head of Open Source says the guides create "the equivalent of a water cooler for the community."

An anonymous reader quotes a report from Ars Technica: Since its introduction, TypeScript has included new features to improve performance, enhance JavaScript compatibility, and extend the range of error checking that the TypeScript compiler performs. TypeScript 2.0 introduces a big step forward here by giving developers greater control over null values. null, used to denote (in some broad, hand-waving sense) that a variable holds no value at all, has been called the billion dollar mistake. Time and time again, programs trip up by not properly checking to see if a variable is null, and for good or ill, every mainstream programming language continues to support the null concept. TypeScript 2.0 brings a range of new features, but the biggest is control over these null values. With TypeScript 2.0, programmers can opt into a new behavior that by default prevents values from being null. With this option enabled, variables by default will be required to have a value and can't be set to null accidentally. This in turn allows the compiler to find other errors such as variables that are never initialized.

Reader edxwelch writes: Reddit user sammiesdog discovered recently that Visual Studio 2015 C++ compiler was inserting calls to a Microsoft telemetry function into binaries. "I compiled a simple program with only main(). When looking at the compiled binary in IDA, I see a call for telemetry_main_invoke_trigger and telemetry_main_return_trigger. I cannot find documentation for these calls, either on the web or in the options page," he wrote. Only after the discovery did Steve Carroll, the dev manager for Visual C++ admit to the "feature" and posted a workaround to remove it.A Microsoft spokesperson confirmed the existence of this behavior to InfoQ, adding that the company wil be removing it in a future preview build. For those who wish to get rid of it, the blog writes: Users who have a copy of VS2015 Update 2 and wish to turn off the telemetry functionality currently being compiled into their code should add notelemetry.obj to their linker command line.

jones_supa writes: The 2014 CAST Research on Application Software Health (CRASH) report states that enterprise software built using a mixture of agile and waterfall methods will result in more robust and secure applications than those built using either agile or waterfall methods alone. Data from CAST's Appmarq benchmarking repository was analyzed to discover global trends in the structural quality of business application software. The report explores the impact of factors such as development method, CMMI maturity level, outsourcing, and other practices on software quality characteristics that are based upon good architectural and coding practices. InfoQ interviewed Bill Curtis, Senior Vice President and Chief Scientist at CAST, about the research done by CAST, structural quality factors, and mixing agile and waterfall methods.

jones_supa writes: The Internet Explorer team at Microsoft recently detailed changes to the JavaScript engine coming in Windows 10. A significant change is the addition of a new tier in the Just-in-Time (JIT) compiler. In Windows 10, the Chakra JS engine now includes a second JIT compiler that bridges the gap between slow, interpreted code and fast, optimized code. It uses this middle-tier compiler, called Simple JIT, as a "good enough" layer that can move execution away from the interpreter quicker than the Full JIT can. Microsoft claims that the changes will allow certain workloads to "run up to 30% faster". The move to a two-tiered JIT compiler structure mirrors what other browsers have done. SpiderMonkey, the JavaScript engine in Firefox, has an interpreter and two compilers: Baseline and IonMonkey. In Google Chrome, the V8 JavaScript engine is also a two-tiered system. It does not use an interpreter, but compiles on a discrete background thread.

jones_supa writes: As part of the Windows 10 Technical Preview, Internet Explorer will introduce HTTP/2 support, along with performance improvements to the Chakra JavaScript engine, and a top-level domains parsing algorithm based on publicsuffix.org. HTTP/2 is a new standard by the Internet Engineering Task Force. Unlike HTTP/1.1, the new standard communicates metadata in binary format to significantly reduce parsing complexity. While binary is usually more efficient than text, the real performance gains are expected to come from multiplexing. This is where multiple requests can be share the same TCP connection. With this, one stalled request won't block other requests from being honored. Header compression is another important performance concern for HTTP.

An anonymous reader writes with this quick bite from Info Q: "Oracle is seeking feedback from the Java community about what it should work on for the next version of Java EE, the popular and widely used enterprise framework. As well as standardizing APIs for PaaS and SaaS the vendor is looking at removing some legacy baggage including EJB 2.x remote and local client view (EJBObject, EJBLocalObject, EJBHome, and EJBLocalHome interfaces) and CORBA."

An anonymous reader writes "Oracle has released the first developer preview of Java 8 for the full range of platforms (Windows, Max OS X, Linux, Solaris). Java 8 is a major update to both language and platform with Lambda expressions, method references, default methods, a new Date and Time API, Compact Profiles, the Nashorn JavaScript Engine, and the removal of the Permanent Generation from the HotSpot virtual machine. 'This milestone is intended for broad testing by developers,' Java Platform Chief Architect Mark Reinhold wrote on his blog. 'We've run all tests on all Oracle-supported platforms and haven't found any glaring issues. We've also fixed many of the bugs discovered since we reached the Feature Complete milestone back in June.' Let the bug hunt commence!" This is the second part of the JDK "Plan B" where JDK 7 was pushed out without cool new features like lambda expressions to prevent stalling language development for too long.

twofishy writes "Something I've noticed amongst financial service companies in London is a growing use of Java in preference to C/C++ for exchange systems, High Frequency Trading and over low-latency work. InfoQ has a good written panel discussion with Peter Lawrey, Martin Thompson, Todd L. Montgomery and Andy Piper. From the article: 'Often the faster an algorithm can be put into the market, the more advantage it has. Many algorithms have a shelf life and quicker time to market is key in taking advantage of that. With the community around Java and the options available, it can definitely be a competitive advantage, as opposed to C or C++ where the options may not be as broad for the use case. Sometimes, though, pure low latency can rule out other concerns. I think currently, the difference in performance between Java and C++ is so close that it's not a black and white decision based solely on speed. Improvements in GC techniques, JIT optimizations, and managed runtimes have made traditional Java weaknesses with respect to performance into some very compelling strengths that are not easy to ignore.'"

twofishy writes "The internet has been buzzing this week with the news that Oracle has ceased to provide free time zone updates outside of the standard JDK release cycle. However, at the end of yesterday the firm appeared to have a change of heart. 'We never intended for a support contract to be required to keep JDK 7 up to date. TZUpdater was made unavailable on March 8 as part of the End of Public Updates for JDK 6, and as soon as we learned that this affected JDK 7 users we initiated the process of making it available for JDK 7 again.'"

twofishy writes "'To avoid the confusion caused by renumbering releases,' Oracle has announced that it is adopting a new numbering scheme for JDK 5.0, JDK 6 and JDK 7. 'The next Limited Update for JDK 7 will be numbered 7u40, and the next 3 CPUs after that will be numbered 7u45, 7u51, and 7u55." The vendor notes that a more elegant solution would require the changing of the version numbering scheme to accommodate different kinds of changes (for example by using 7u44-2 ). However this cannot be implemented outside of a major release, since doing so might break existing code that parses version strings (possibly including the Java auto-update system)" Here's Oracle's announcement.

twofishy writes "Struts 1, the venerable Java MVC Web framework, has reached End Of Life status, the Apache foundation has announced. In a sense, the move simply formalises what has already happened, as the Struts team have focused their efforts on version 2; the last release of Struts 1 was version 1.3.10 in December 2008. The change of status does mean however that, whilst the code and documentation will still be available, no further security patches or bug fixes will be issued."

An anonymous reader writes "The H.265 codec standard, the successor of H.264, has been approved, promising support for 8k UHD and lower bandwidth, but the patent issues plaguing H.264 remain." Here's the announcement from the ITU. From the article: "Patents remain an important issue as it was with H.264, Google proposing WebM, a new codec standard based on VP8, back in 2010, one that would be royalties free. They also included it in Chrome, with the intent to replace H.264, but this attempt never materialized. Mozilla and Opera also included WebM in their browsers with the same purpose, but they never discarded H.264 because most of the video out there is coded with it. MPEG LA, the owner of a patent pool covering H.264, promised that H.264 internet videos delivered for free will be forever royalty free, but who knows what will happen with H.265? Will they request royalties for free content or not? It remains to be seen. In the meantime, H.264 remains the only codec with wide adoption, and H.265 will probably follow on its steps."

mikejuk writes "The Mono project is about the only group of people actively talking up .NET and developing it, but in an interview Miguel de Icaza has admitted that Moonlight, the Mono version of Silverlight, isn't worth the effort any more. He said, 'Silverlight has not gained much adoption on the web, so it did not become the must-have technology that I thought [it] would have to become. And Microsoft added artificial restrictions to Silverlight that made it useless for desktop programming. These days we no longer believe that Silverlight is a suitable platform for write-once-run-anywhere technology, there are just too many limitations for it to be useful.'"

sl4shd0rk writes "Hackers can now build applications directly on their Android devices with the beta release of AIDE. The Android IDE is at beta version 7, and already allows editing and compiling of apps as well as integration with LogCat. AIDE is even compatible with projects started on Eclipse so you can move a project over and work on it. Finally, a reason to get yourself that Transformer keyboard dock?" sl4shd0rk also provided a screencast which is attached. InfoQ has a short interview with the developers. Mildly interesting is that it does the compilation on device instead of shipping the work off to some network service or other. The app is, like a lot of Android stuff, only free cost with no corresponding source code at the moment.

First time accepted submitter twofishy writes "After an undeniably rocky start, which saw high profile resignations from the JCP, including Doug Lea (who remains active in the OpenJDK), and the Apache Software Foundation, Oracle is making significant efforts to re-engage with the wider Java ecosystem, a theme which it talked up at the most recent JavaOne conference. The company is working hard to engage with the Java User Group leaders and Java Champions, membership of the OpenJDK project is growing, and the company is making efforts to reform the Java Community Process to improve transparency. The firm has also published a clear, well-defined Java roadmap toward Java 8 and Java 9."

New submitter ProbablyJoe writes "InfoQ reports that Adobe is to donate its web application SDK, Flex, to an 'an established open source foundation' — suspected to either be the Open Spoon Foundation (who have been working on an open source fork of Flex), or the more established Apache Foundation. Adobe has stated on its blog that they consider HTML5 to be a better technology for the future than its own Flex platform, causing frustration among developers who have used the platform for enterprise applications. Is this a generous contribution to the open source community, or just Adobe offloading another failing technology?"

An anonymous reader writes "Google's new language landed with a loud thud, causing lots of interesting debates about the best place to stick semicolons... An article [in InfoQ] ... looks at some of the less discussed features. Snapshots seem to bring something like Smalltalk images and allow instant startup of applications (something Java has spent the last 15 years not delivering). Isolates are like OS processes and communicate with message passing — and as the article suggests, can fix the problem of Garbage Collection pauses by splitting up the heap (sounds like Erlang). There's more, mostly about features that remove some dynamic behavior in order to make startup and code analysis easier. Maybe Dart is worth a second look?"

There's been a lot of attention to the way Windows 8 looks; reader aabelro writes with an interesting look at one way it behaves. The article begins thus: "Microsoft has created a new mechanism for sharing information between applications in Windows 8 called Windows Share. Apps can share text, bitmaps, HTML, URI, files, and other type of data, and the usage scenarios are numerous. For example, the app receiving the information can post it to Tweeter or Facebook[, making] it easy to post information to a social network without actually visiting it." Here's a short (video) explanation at MSDN, too.

An anonymous reader writes "Microsoft's Neal Gafter, who was primary designer and implementer of the Java SE 4 and 5 language enhancements and now works for Microsoft on .NET platform languages, discusses the impact of Oracle's acquisition of Sun on Java, makes the case for adding segmented stacks and a meta-object protocol to Java, and offers some insights into how Java and C#/.NET compare." The first couple of answers meander a bit, but after that the interview picks up and is a pretty good read.

aabelro writes "Google, Microsoft and Yahoo! have decided to propose a common markup vocabulary, Schema.org, based on the Microdata format, simplifying the job of webmasters who want to give meaning to their web pages' content." Manu Sporny, chair of the W3C group that created RDFa, added his (personal) dissenting opinion about Schema, calling it a 'false choice,' and saying, "The entire Web community should decide which features should be supported – not just Microsoft or Google or Yahoo."

aabelro writes "Google has announced at I/O 2011 the availability of their Storage service to all developers without the need for an invitation. The service has been enhanced with OAuth 2.0 support, simplified account management through the API Console, a new EU storage region, and a new API version."

An anonymous reader writes "IonMonkey is the name of Mozilla's new JavaScript JIT compiler, which aims to enable many new optimizations in the SpiderMonkey JavaScript engine. InfoQ had a small Q&A with Lead Developer David Anderson, about this new development that could bring significant improvements in products that use the SpiderMonkey engine like Firefox, Thunderbird, Adobe Acrobat, MongoDB and more. This new JIT infrastructure, will feature SSA compiler intermediate representations which will facilitate advanced optimizations such as type specialization, function inlining, linear-scan register allocation, dead-code elimination, and loop-invariant code motion."

Yesterday we noted that Firefox 4 is out in the wild. Since then, the popular browser has been downloaded 6 million times, double the numbers reported for MSIE9. Now the development team is talking about a new development process and what to expect for FF 5 and 6. And unsurprisingly, naysayers proclaim that IE will survive, while Firefox will die.

An anonymous reader writes "Ruby/RoR in NetBeans made headlines three years ago, but after Sun was acquired by Oracle there where fears that support for dynamic languages would suffer, as this IDE would be downsized. This has become a reality, since as of version 7, NetBeans will no longer support Ruby."

aabelro writes "On December 22th, 1600 GMT, the Skype services started to become unavailable, in the beginning for a small part of the users, then for more and more, until the network was down for about 24 hours. A week later, Lars Rabbe, CIO at Skype, explained what happened in a post-mortem analysis of the outage."

aabelro writes "Don Syme has announced the release of the F# compiler source code as a code drop under Apache 2.0. He wrote, 'The F# PowerPack now includes libraries, tools and the compiler/library source code drops. I'd like to take a moment to explain the F# team's approach to this. Firstly, the source for the F# compiler in our MSI/CTP releases has been available for some time, in the releases themselves, so in that sense there's not much new in this release. Secondly, we've always made sure we have a free download binary release of F# available, and will continue to do that, and that should still be the main way you "get" a release of F#. However, we've long discussed making compiler+library source available in a different way. After some discussion, we've decided to do this via a "code drop" model, where we make available versions of the compiler+library code logically matching each release of the F# language itself.'"

snitch writes "Apple has created an HTML5 Showcase that presents its vision for the next generation of the WWW. The fact that this page is only accessible using the Safari browser, while Apple advocates about web standards, has caused many to criticize the company's lack of broader platform support. The showcase demonstrates several HTML5 capabilities and features that have to do with video, typography, transitions, audio, etc. Further, on the front page the company states that 'Standards aren't add-ons to the web. They are the web. And you can start using them today.' The latter statement falls short by the fact that the featured examples only work with the Safari browser, and in the case of the CSS 3D transforms demonstration, require Mac OS X Snow Leopard (Safari PC or plain Leopard won't do)."

eldavojohn writes "Programming Clojure by Stuart Halloway was very near to the perfect book for me. It covers many things common to many Lisp languages while highlighting in moderate detail the things that make Clojure unique and worthy of some attention. The book spends a large amount of time dealing with the intricacies of interfacing fluidly with Java (down to a package rewrite inside a large project). This fits me perfectly as a Java programmer, and I now feel ready to experiment with peppering functional language capabilities into an object oriented language. The book also strives to show how to simplify multithreading through functional programming, which is good because I find multithreading in Java a serious headache that few are good at. Programming Clojure, released in May 2009, is currently the only book out there devoted to Clojure, and the introduction is written by the language's creator, Rich Hickey, who says, 'What is so thrilling about Stuart's book is the extent to which he "gets" Clojure.' The book earns its place on the Pragmatic Bookshelf by guiding the user through rewriting a part of Ant into a new build tool called Lancet — adding to the project what you just learned about Clojure at the end of each chapter." Keep reading for the rest of eldavojohn's review. Programming Clojure author Stuart Halloway pages 304 publisher The Pragmatic Bookshelf rating 8/10 reviewer eldavojohn ISBN 978-1-934356-33-3 summary A firm definition of Clojure via examples coupled with the beginnings of actually programming Clojure. First, a lot of you are probably wondering what Clojure is and asking me why you should care at all about it. Well, Clojure is a functional programming (FP) language that runs on top of the extremely pervasive Java Virtual Machine and in doing so seems to offer a simpler way of multithreaded programming. It belongs to the family of languages that are Lisps and as a result this book covers a lot of remedial material that is common to other Lisp languages. If you're a serious lisp programmer, you'll be able to skip some of this book (the intro will guide you). Clojure has rarely been mentioned on Slashdot with the resulting comments revealing largely confusion or considering it a buzzword. It's going to be hard to write this review about the book instead of the language being that 99% of what I know about Clojure comes from this book. If you work through this book linearly, you must also use the command line read-eval-print loop (REPL) that, similar to Ruby's IRB, allows you to get hands on with Clojure and Halloway's examples.

Both Hickey and Halloway are very active in Clojure development. In fact, Halloway has a video out on types and protocols, new developments in Clojure 1.2 since the book went to print. Halloway does a good job at providing examples, keeping the book pragmatic and showing you the "wrong" way before incrementally showing you how to correctly accomplish various goals in Clojure. But he loses two points on this review for two reasons. One is that he over evangelizes about Clojure. It would lend a lot more credibility to everything else he says if he would just relent and abstain a bit from painting Clojure as the best language for any task. This ties into my second point which is the fact that books on programming languages are supposed to give the reader two very valuable things: knowledge of when to use the language and knowledge of when not to use the language. Programming Clojure is lacking in the latter--this is not a unique problem as most books about a language really sell their language. All too often in my professional career I see a solution and think, "Wow, that really was not the right tool for the job." (I'm looking at you, Java) Clojure definitely has its strengths and weaknesses despite very little evidence of the latter in this book although I was directed to a QCon presentation where the author speaks more about where Clojure excels in real life.

That said, the book is a great fit for the object oriented Java developer who does not also code a lisp-like language regularly. I say that because Chapter Two deals with reviewing all of the facets of Clojure--most of which are found in other Lisp languages which might be seen as remedial to a proficient Lisp developer. However, before you skip it entirely, there are important notes that Halloway injects into these chapters ranging from how not to do things in Clojure to the minute differences and implications they hold. Chapter Five dives into the fundamentals and features of functional programming in Clojure. This chapter was especially useful to me as I'm not used to languages featuring things like lazy sequences, caching of results or tail-call optimization. Working through the examples in Chapter Five really opened my eyes to some of the more powerful aspects of FP. Like how an infinite sequence can easily be handled by Clojure and its laziness allows you to only pay for what you need from that sequence. While definitions of infinite sequences are also possible in Haskell or Python, Clojure brings this capability to the JVM (not that anything is preventing a more verbose Java library from handling such structures).

Chapter Three focuses a lot on Clojure's interaction with Java and does a great job of showing you how to rewrite part of your Java project into Clojure and run it on the JVM. This includes calling Java from Clojure, creating and compiling Clojure into java classes, handling Java exceptions in Clojure and ends with the beginning work in Lancet (the build tool the book strives to create using what we learn in each chapter). It also contains a bit on optimizing your performance when working with Java in Clojure. This theme continues through the book as Halloway knows that one of Clojure's main selling points is that it can be so much faster than Java if you're willing to put in the extra work and planning to utilize pure functional programming.

In Java, everything is an object. In Scheme, everything is a list. Well in Clojure, the main staple is sequences which brings us to Chapter Four: Unifying Data with Sequences. While this chapter succeeds in teaching how to load data into sequences, how to consume data from sequences and how to force evaluation of lazy sequences, it felt like one of the weakest chapters in the book. This is all necessary in learning Clojure but Halloway skimps on examples and could stand to add some more examples on what is and isn't seq-able, seq-ing on various things and performing functions on various things.

Multicore chips are all the rage these days. And right now it seems that developers are by and large content with coding single threaded applications. But that may change in the future when the user expects more than a few cores in usage. In the introduction, Halloway argues a few reasons why we all should use Clojure and one of those reasons happens to be the somewhat sound logic that we will all have cores coming out of our ears in the near future. That means that as a developer you have the option to spawn more threads which means coordination of threads which means you will be forced to do the dirty dance of concurrency. Chapter Six is entirely devoted to this and, honestly, I reread a lot of this chapter as there are several update mechanisms and models that you can use to manage concurrency in Clojure. Unsurprisingly there is no silver bullet for concurrency even in Clojure. This book has but a handful of figures and their formatting leaves much to be desired but the two in this chapter are necessary references for deciding if you should use refs and software transactional memory, atoms, agents, vars or classic Java locks. This is a potent chapter that ends with a snake game implementation in Clojure demonstrating some basic concurrency. While Clojure protects you from some classically complex issues and may make concurrency vastly more succinct, it still requires a lot of thought and planning. Halloway provides good direction but clearly hands on experience is a necessity in this realm.

Chapter Seven focuses entirely on macros and is somewhat disheartening in that it presents an extremely powerful feature of Clojure that is also very complex. Halloway gives two rules and an exception for Macro Club. The first rule is: "Don't Write Macros." The second rule is: "Write Macros if That Is the Only Way to Encapsulate a Pattern." The exception is you can also write macros if it makes calling your code easier. Halloway does a good job of explaining the basics of macros in Clojure and breaks them down via a taxonomy into categories and examples of macros in Clojure. Macros are a necessity when you're trying to augment Clojure by adding features to it or if you are creating a Domain-Specific Language (DSL). Macros in Clojure do seem easier than macros in most other Lisp languages. At the end of Chapter Seven, you create a basic DSL for Lancet which was helpful even though I was left feeling helpless in the face of macros. Despite the complexity of macros in Chapter Seven, Eight's multimethods are similar to Java polymorphism and was much easier to wrap my head around than macros. Multimethods are used very infrequently (seven times in the five thousand lines that compose the Clojure core).

Chapter Nine is unfortunately less than twenty pages and deals with "Clojure in the Wild." You would think that a book in the series of Pragmatic Programmer would have more pragmatism than the features of a language with Lancet but let's face it--Clojure is a relatively young language. Nine covers automated tests, data access and web development. The automated testing is a short section on Clojure's test-is packaging. The database stuff appears to be little more than wrappers around the already mature JDBC. The web development consists of an intro to Compojure which is similar to web.py and Sinatra. Compojure shows a lot of promise in reducing the amount of code one needs to write a basic web application. It lacks the feature set and support that Rails has with rapidly building CRUD applications but holds a lot of potential to be flushed out into something similarly powerful. Halloway says his introductions to these projects should "whet your appetite for the exciting world of Clojure development" but I think a more accurate description is that these brief brushes with functional projects leaves the reader ravenously blinded by hunger for more.

Some final thoughts on the book: I caught only two very minor typos in the book. It's all English and code. There were no pictures or illustrations in this book except for one on page 96 in which a tiny drawing appears named Joe who asks a question about vectors. Oddly enough, I didn't find Joe on any of the other three hundred pages. It was very easy to work through this book from cover to cover and the example code was very instrumental in my understanding of Clojure. As a Java monkey, rereading sections seemed a requirement although the book is concise enough for me to enjoy in my free time over one week. Halloway cites mostly websites and utilizes tinyurl to reference blogs like Steve Yegge's blog and frequently he references Wikipedia. Only three of his many citations are other printed books (although one of them is Gödel, Escher, Bach: An Eternal Golden Braid). Halloway's greatest strength is the engaging examples (like the Hofstadter Sequence) that he picks and provides to the user and I hope that future editions of the book build on this as well as expand on the growing base of Clojure projects out there. His github is rife with both instructive and pragmatic examples that could stand to be included in a future book.

Some final thoughts on the language: Clojure holds a lot of potential that is yet to be realized. I cannot say yet whether the succinct syntax offers a good balance between quick coding and readability. To the uninitiated, the code can look like a jumble of symbols. Yes, we escape the verbosity of Java and the kingdom of nouns but is what Clojure offers (a neighboring kingdom of verbs) better? While Clojure is concise, it requires a lot of keywords which required a lot of usage look up when starting. Clojure code is potent and powerful. A mere five thousand lines of Clojure code create your engine--the core of the language. I assume this brevity is due to ingenious reuse that Clojure can offer but I would hate to be the person to maintain that code if I was not the author. What's better is that this code is quickly conjured at the REPL if you wish to read it yourself or augment a feature. A sage coworker who has seen much more than I in this business of software development recommended Clojure to me. He was right that it is a very interesting and innovative language but in my opinion it has a long way to go before it becomes the next Ruby or Java. Clojure needs an equivalent to Ruby on Rails and it's fighting an uphill battle against all the developers like myself that left college with so much object oriented coding and so little functional programming (although Scheme is my alma mater's weed out course). If you find yourself stagnating and are thirsty for some continuing education in the form of a stimulating challenge, I recommend Clojure (and this book on Clojure). Hopefully Clojure's full potential is realized by the community and it finds its deserved place in many developer's tool sets as the right tool for some jobs.

You can find Programming Clojure in three DRM-free formats and hard copy from the publisher's site. For a sample of the author's writing and to get a feel for how he injects Clojure code into it, check out his blogs on his company's website.

You can purchase Programming Clojure from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Lord Straxus writes "In this presentation (video) from the JVM Languages Summit 2009, Cliff Click talks about why it's almost impossible to tell what an x86 chip is really doing to your code due to all of the crazy kung-fu and ninjitsu it does to your code while it's running. This talk is an excellent drill-down into the internals of the x86 chip, and it's a great way to get an understanding of what really goes on down at the hardware and why certain types of applications run so much faster than other types of applications. Dr. Cliff really knows his stuff!"

aabelro writes "Google proposes to the FCC to become the administrator of a White Spaces Database containing geo-location information about devices using the free channels in the radio spectrum."

An anonymous reader writes to tell us that a recent FAQ released by Oracle outlines the plans for many of Sun's popular products like GlassFish, MySQL, and NetBeans. Many are worried at some of the possible avenues the decisions outlined could lead to, especially with respect to NetBeans. "What should have happened, Oracle should not have missed a beat and should have announced work on Oracle plugins for NetBeans and active Oracle support of NetBeans. This type of announcement would have brought a large and some-what skeptical NetBeans community much closer to Oracle. It would have been a big win for Oracle. NetBeans will continue to grow either way - but Oracle has missed a big chance to really change perceptions and at the same time move their tools to another level. What JDeveloper lacks is buzz, a wealth of community developed plugins, a wealth of support for other languages and a very, very large community. And of course it does not offer a platform in the NetBeans and Eclipse sense of the word. This is a huge missed opportunity for Oracle."

As Google Wave is about to be released to 100,000 beta testers tomorrow, reader snitch writes in with a link to an in-depth interview with Dhanji Prasanna, whose title is Core Engineer. It covers some of the technologies, tools, and best practices used in building Wave. "InfoQ: Would you like to give us a short technical outline of what happens to a message (blip) from the moment a user types it in the web client, until becomes available to every one else that is participating in that wave — humans or robots? ... Dhanji: Sure, a message written in the client is transformed into a series of operations that are sent to the server in real time. After authenticating and finding the appropriate user session, the ops are routed to the hosted conversation. Here these ops are transformed and applied against other incoming op streams from other users. The hosted conversation then broadcasts the valid set of changes back to other users, and to any listening robots. This includes special robots like the ones that handle spell checking, and one that handles livesearch (seen in the center search-panel), as well as explicit robotic participants that people have developed. Robotic participants write their changes in response to a user's and these are similarly converted into ops, applied and re-broadcast."

An anonymous reader writes 'In the article entitled Apple vs. Microsoft — A Website Usability Study, Dmitry Fadeyev, co-founder of Pixelshell, compares Apple's and Microsoft's web sites from a usability perspective, and Apple is the winner. Scott Barnes, PM at Microsoft, agrees with him and suggests the problem is because various site sub-domains have different management.'

murphee writes "Flight delayed again? Should have asked FlightCaster, a new site using statistical analysis to predict the delay of your flight in real-time. What's even better, the services is fully buzzword compliant: it's built with Clojure, distributed with Hadoop, served with Rails, and hosted on Heroku. This interview with one of the FlightCaster developers gives the gory details on architecture, Clojure tips, and your boss a reason to let you have all the multimethods and macros you can eat. Seems like now that O'Reilly's publishing a LISP book, the Age of Parenthesus has come..."

snitch writes with this snippet from InfoQ about the current state of Google Wave: "With the Google Wave Preview scheduled for public availability on September 30th, Wave API Tech Lead Douwe Osinga has posted on the Wave Google Group about what the team has been working on along with some future directions. Up until now, with the limited availability of testing accounts there have been complaints on the Google Group from users that wanted to get their hands on this new technology but didn't have access to the sandbox. As Douwe explains, the team has been busy all this time with stability issues and more."

Last week you asked Jazz technical lead Erich Gamma questions about Jazz or anything else in his realm of expertise. Here are his answers, along with many external links and places to continue the conversation if you are interested. Why Jazz? -- by autophile (640621)

Could you explain, minus the marketing speak that seems to pervade the IBM site, what is Jazz, what makes it a community-oriented developer's site, why is it different from, say, sourceforge.net, and if Jazz is so community-oriented and yet apparently tied in to Rational, where are the community versions (not trials, not demos, not limited to the point of uselessness functionality) of Rational products?

Jazz is not a product but it is the name of a project that has the goal of building a new set of team products and to better integrate existing products.

The Jazz project was kicked-off in 2005. At that time we observed that the tooling situation for an individual developer using an IDE like Eclipse was pretty good. However, when it came to working as a team, our own experience and feedback from our customers indicated there are still many pain points. Our own experience comes from working for many years on Eclipse. We developed in a globally distributed team, spread across many time zones, and using many agile practices. The goal of the Jazz project was to take a fresh look at how teams work together and to build a new generation of products from the ground up that makes development more collaborative, but also more fun. We put the team at the center of all our designs. Initially we focused on development related pain points like support for iterative planning, painless build submissions, collaborating and fixing broken builds, simplifying parallel development, easy progress tracking, and finally improving transparency. Collaboration becomes more effective with increased transparency. One of the goals here is to make it easy for everybody to know what is going on in the project without having to ask. Since then we expanded the scope to cover the role of testers and business analysts. The set of new products that were built from the ground up include:

• Rational Team Concert (RTC): Provides a new customizable work item/defect tracking system, a continuous build system, a new source control system, and customizable agile planning that supports project management practices like the ones from Scrum, and dashboards and reports. Version 2.0 has actually shipped just a week ago.
• Rational Quality Manager (RQM): Provides test management, test planning, and includes a test lab management component.
• Rational Requirements Composer (RRC): Provides requirements definition for business analysts, client stakeholders and software developers using a variety of capture techniques.

These products share a common infrastructure using the building blocks we refer to as the Jazz Foundation. The Foundation provides a common set of services that can be leveraged by a Jazz tool. To enable integration with existing tools, the Jazz Foundation supports the Open Services for Lifecycle Collaboration initiative; an independent project to define a set of REST based protocols for sharing information across disparate tools. Actually, we are not only contributing to the specification, we have actually used the OSLC specifications for integrating the above tools.

Finally, we have grown a community around the Jazz project on www.jazz.net. Transparency and feedback are very important to us, not only for the tools we provide, but also for how we develop the products ourselves. To get that direct feedback, we do our development on jazz.net out in the open. On jazz.net you can interact with the development team, learn about our development plans, see our RTC powered dashboards, submit defects and enhancements, or download intermediate milestone builds.

If you want to read about how all these capabilities come together, there is a new eBook available for download. The eBook describes, using scenarios, how business analysts, development teams, and testers collaborate using the above mentioned products.

If you are interested in how we develop our products using Rational Team Concert in a globally distributed team, I did a web cast that sheds light on our development practices.

Rather than reading feature comparisons, I suggest that you jump in and give Rational Team Concert 2.0 a try. We made it very easy to kick the Team Concert tires. In less than 30 minutes you will have a running server, a client, and a sample project for a small team working on a fictitious JUnit release. There is also a community edition called Express-C (free for up to 3 users). Based on community feedback, we have made more features available in the Express-C edition. You can find the descriptions of the editions on the Jazz site. For those of you that do prefer to compare features, there is also a feature overview of RTC . If you have questions, feel free to post them to the user forum on jazz.net. Our development team is always there to answer questions.



Rational? -- by an anonymous reader

I work in a small shop that makes some use of Websphere Application Server and the Rational development tools. I basically find the entire structure of the IBM software offerings relating to the above technologies incomprehensible. Products are constantly being renamed, discontinued, bundled, unbundled and rebranded. Names are long, generic, and practically interchangeable, and so are the feature lists. How do you plan to run a community support site based around this hodge-podge? I would assume the volatile nature of IBM's software marketing makes your task something approaching impossible. How do you expect to build a strong developer community based around products that are in a constant flux? I don't see any way around ending up with a large number of granular, isolated communities that spring up around specific products and thrive for a year or two. In short, how do you plan to unify a developer community without IBM first unifying the software development platform that this community is to be built around?

Obviously the Rational portfolio has grown through acquisitions (Build Forge, Watchfire and Telelogic being the most recent), and the process of bringing these acquired products into a logical product family while minimizing disruption for existing users is an ongoing effort. One goal of the Jazz project is to improve the integration of existing products by providing the Jazz integration architecture and by contributing to the OSLC initiative as mentioned above.

The Jazz community site is the live development infrastructure for the Jazz project and the new Jazz products. We launched www.jazz.net in 2006 together with the availability of the first Rational Team Concert beta version. As you can see from the URL it is "ibm" neutral and focuses on Jazz products. Since then the community has rapidly grown and there are now over 17000 participants in Jazz forums. Customers really appreciate the direct communication channel with the development team. Given the positive feedback we have recently on-boarded two additional Jazz products on jazz.net: Rational Requirements Composer and Rational Quality Manager. This was combined with a reorganization of the site itself to optimize for the new projects, improve user experience, and create a high quality technical library of materials created by the development teams themselves to help educate and get teams set up and running and become productive very quickly. Additional Jazz products will on-board on jazz.net as they emerge. Some of the Jazz products will also be in flux, the point is that we make them available early, are transparent about their development and invite users to provide feedback.



RTC vs CQ and CC -- by SunSunich (1588709)

First of all let me congratulate you on the successful launch of version 2.0 of RTC and 1.0 JF. It is really great work, thank you and all the Jazz Team. The functionality of Rational Team Concert greatly overlaps with the ClearQuest and ClearCase. Why is it necessary to create a new product? Why not just release it as new versions of old? For customers, it could be easier to adapt. What is the future of CQ|CC, how you see it? Thank you.

With the Jazz project we are trying to do something new and do it in the open - but clearly we understand that we can't just leave the existing customers behind. As mentioned in the question about the Jazz project above, we have experienced several pain points with the existing tools. A common point of friction was the lack of integration which resulted in a lack of transparency. One lesson from Eclipse was that to achieve integration you need some common foundation or integration platform. Retrofitting a new integration platform wasn't a viable approach and in addition there were additional pressures to better support agile practices. While the Jazz project did start from the ground-up, we reused many ideas from CC and CQ. For example, the stream model from CC or the customization support from CQ. Once we went down this path it was obvious that we needed an integration solution for CC and CQ.

In RTC 1.0 we provided "synchronizer" connectors which can synchronize data between the Jazz and the CC or CQ repositories. With this functionality, an agile team can start to use RTC while periodically synchronizing their code with the "mothership" CC repository. For RTC 2.0 we have expanded the integration options with the support "bridge" connectors. A bridge doesn't synchronize the data but rather links artifacts across repositories. The CC Bridge allows linking a ClearCase UCM activity with an RTC work item. This allows CC users to continue using CC, but also benefit from the additional capabilities RTC offers such as agile planning support, work items, reports, dashboards, notifications etc. The CQ Bridge provides linking CQ Records and RTC work items. Finally, both RTC and CQ implement the Open Services for Life Cycle Collaboration specification for change management systems. This enables a third tool like the Rational Quality Manager to work with either RTC or CQ when it comes to filing defects for failed tests, for example.

To conclude, there is still a significant investment in enhancing ClearCase and ClearQuest and this will continue. RTC 2.0 provides good options for users who want to use RTC, CQ and CC together. All these options have been enriched further in 2.0 to enable gradual adoption.



Could Jazz Benefit from a Distributed Model? -- by A.K.A_Magnet (860822)

Do you think Jazz could gain from a distributed model, like git does for source control management, where the repositories can be forked and kept synchronized upstream/downstream (a bit like a "progressive fork" where fixes can be shared but the project can be forked for various reasons)? I heard there is a git connector in incubation but it seems to me more than just code artifacts should be distributed. After enjoying the many benefits of distributed SCMs, it's hard to go back, and I think at least issue management could gain from the same model.

Using the terminology from above the Git integration will be a bridge connector. It will be available as an incubator on jazz.net soon and it leverages the OSLC change management specification supported by RTC to create the linkage to RTC work items. Flowing changes across repositories is appealing and this feature is in our backlog. Some explorations to support a distributed Jazz SCM were already undertaken. Details on the current status and open issues are available on the developer wiki on jazz.net.

Cleaning Up Collaboration -- by eldavojohn (898314)

Jazz seems to rely heavily on developer community and their collaboration--and the influence for Jazz is said to be the World Wide Web. "The Jazz portfolio consists of a common platform and a set of tools that enable all of the members of the extended development team to collaborate more easily." The biggest problem I have with collaboration tools is the metadata. No one does it right. Someone writes a blog or uploads a document but doesn't tag it. Enterprise search is broken. Management hands us wikis yet no one has the time or patience to maintain them. The protective blanket of "it's agile, baby" shields us from any beat downs. And with every new tool I realize that it's not the tool that improves collaboration, it's the team. Look at Slashdot's tagging system. Does it help me that one hundred stories are tagged with "no"? Collaboration seems to spontaneously work but is often out of your control when it does and doesn't. How does Jazz fix these problems? How does Jazz improve collaboration when it seems to me that tools are such a small part of collaboration? Will a small development team be able to use such a large set of tools?

I agree that no tool can fix collaboration problems and the team plays the main part in the game. In the Jazz project, we are focusing on collaboration in the context of software artifacts like builds, change sets, test plans, defects, or baselines. Software artifacts are semantic rich, structured, and there are typically rules, permissions or approvals involved when it comes to changing artifacts. Jazz products can improve the collaboration around software artifacts by making these rules explicit. Our goal was that the tool not only acts as the police but also as a guide that helps team members conform to the rules. Let's use Rational Team Concert as an example. When a change set requires a review before it is shared with the team, the tool will not just flag you when the review is missing, it also offers to initiate the review process for you. This involves suspending the changes from the current work space, attaching them to a work item, and notifying the reviewer that there is a pending review.

Behind all this is a process component in the Jazz Foundation that allows you to configure these rules in a flexible way. The flexibility is required since otherwise tools can get easily in the way. A team operates differently during an early exploration of a product and one week before it ships. The rules can be specific to a particular role, or a particular team, and the development phase of the project. Here is an analog example to tagging a blog: checking in a change set and wanting to track the reason for the change. To guide users, you can define a precondition for the check-in operation that will ensure that the change set is linked to a work item tracking the reason for the change. When a user attempts to check-in a change set without an associated work item, the user is shown a list of work items that they own to choose from. If none of them apply, the user can easily create a new work item on the fly to complete the check-in. As a side effect the change set and the work item are now linked together. As you work with Rational Team Concert it establishes many such links between artifacts for you in the context of your work. For example, the work items that are fixed and included in a build are linked to the build result artifact. These links increase the transparency and allow everybody in the team to understand why something was changed, which will helps collaboration.

In addition to making team roles and rules more explicit, the tools improve collaboration by helping team members stay on top of changes that affect the whole team. The team's current sprint or iteration plan and the current progress are easily accessible for everybody to see. Team members are notified about events in their team and they can track event feeds using RSS readers and aggregators. Similarly, broken builds are linked to a work item where the discussion about the broken build takes place and this work item is then easily visible and accessible from the team's dashboard. These are just a few examples that illustrate how a tool can facilitate the collaboration in the context of software artifacts.

Now regarding the question on small development teams, RTC is designed to scale up from single teams working in a single release to multiple (even distributed) teams working on multiple releases and you can easily use RTC for small teams. In fact, the Express-C edition is free for teams up to three. Even a small team needs to do the backlog and sprint planning, needs continuous builds, needs to track progress, manages defects and wants to make the current state of the project visible on dashboards.

The Directions of the Eclipse Foundation -- by eldavojohn (898314)

Eclipse has been going on since the early 2000s and six days ago enjoyed the release of Galileo (v3.5). If you've had time to look at recent release, what are your opinions on what Eclipse has become? Has it made any wrong turns? How do you respond to criticisms of "bloat" or "too resource intensive"? Do you see it becoming more than what it is or transforming?

The Galileo release is quite an achievement. Over 30 projects with over 380 committers from over 40 organizations have contributed to this joint release. Obviously you do not want to consume Galileo all at once but rather pick one of the available packages that suit your needs. Now that my team's focus is on Jazz and Rational Team Concert, we have become consumers of many Eclipse projects. Having a release train with aligned project releases is a big help for us and is the right direction.

As consumers we also appreciate the API stability that Eclipse platform provides. Regarding bloat, the API stability is not free. It means that once something has surfaced as an API, you cannot remove or change it anymore. For example, if you look under the covers in the Eclipse source code, you find three different preference store mechanisms. This is the price you pay for API stability. Actually, Eclipse now includes some nice tools to track API changes and more.

The "too resource intensive" criticism depends on which packages/plug-ins you are using. Eclipse is an extensible system and is therefore vulnerable to contributions that can be too resource hungry. To keep a software system interesting to users, you need a constant flow of new features. The challenge is to preserve the performance and resource characteristics as new features are added. The Eclipse SDK team does measurements to track this. There is a set of performance JUnit tests that are run for each build. Once a test runs slower than the baseline from the previous release, the test turns red. The results are published for each build. Here is an example report from Eclipse 3.5. Based on our own use of Eclipse for developing RTC, I do not experience that Eclipse has become slower over time or more resource intensive.

Looking back, I don't necessarily see wrong turns, but rather some turns we probably could have taken but didn't. For example, the Eclipse platform is language agnostic and the Java Development tools built on top of the platform. There is a language toolkit layer (LTK) in between the platform that provides some generic infrastructure for implementing refactorings. However, this layer is thinner than implementers of new languages on Eclipse would like. They therefore have to resort to copy code from JDT. This is obviously not ideal. Even though we were aware of this issue, we didn't have the cycles to pursue a more generic language layer. Having said that, I must say that the Eclipse C Development tool is cool in Galileo and there is good support for many other languages. There also is the Dynamic Languages Toolkit incubator project at Eclipse.org.,



Will SWT and Swing ever merge in Eclipse? -- Fuzuli (135489)

I have to build quite complex tools using GEF and GMF, and there are many cases where I'd like to have the power of Java2D, and reuse some of the great frameworks out there built on Swing. More and more people are using AWT/SWT bridge, since SWT does not provide an underlying drawing framework as rich as Java2D. Eclipse has great things like EMF, and the platform is number one choice for tooling, but when it comes to things like Bezier curves etc, Swing is much easier to use. So are we going to see more developer friendly versions of Eclipse where Swing is more available to us?

SWT has continually improved its advanced graphics API for drawing Bezier curves, alpha blending, gradients etc. You can see it in action in the GraphicsExample (http://www.eclipse.org/swt/examples.php.) and there are several example snippets. If the current support is not sufficient, then you should file enhancement requests against the SWT component at eclipse.org.

As you mention SWT provides the support to enable the SWT/Swing integration and enables embedding an AWT hierarchy in a SWT widget hierarchy. The SWT team has currently no plans go beyond this. However, there is also the Albireo project at Eclipse.org. This is a technology project in incubation with the goal of simplifying the task of combining user interface components from the Swing and SWT toolkits.

A follow-up question -- by an anonymous reader

will SWT and the whole Eclipse workbench ever run in a Web browser? We have built a product based on SWT/Eclipse but our customers complain they cannot run it from a browser and instead have to download 200MB+ worth of plugins before they even start evaluating our product.

The eclipse e4 project has been investigating this very question. At EclipseCon 2009, the team provided an update and showed some interesting demos. You can find more details about the e4 project and a presentation covering the eclipse/desktop exploration online.

The short answer is that there is no free lunch for existing applications which generally must be re-factored to take into account that the application is now split between client and server. For your application to run in a web browser, the libraries it uses must also run in a web browser. In particular, one needs web equivalents of the workbench facilities that Eclipse RCP apps are based on. The approach currently being investigated is to provide "e4 workbench services". The e4 project is increasing support for running JavaScript on the desktop. As a consequence when the application is written against these workbench services, the same JS code can run unchanged in both the desktop and the web. In combination, this provides a path to achieving a good user experience in both the desktop and the web with some reuse.

A different approach being investigated in parallel is the eclipse Rich Ajax Project, which is also part of the Galileo release. RAP runs your SWT widgets remotely in a web browser, which have some other trade-offs as the approach used by e4.



On strong typing, and design patterns and testing -- by bADlOGIN (133391)

A number of weak typing language zealots like to point out that Design patterns is simply a way to make strongly typed languages "suck less". This can be a compelling argument in terms of simplicity and syntax in examples when you take a look at books like "Design Patterns in Ruby" compared with "Design Patterns: Elements of Reusable Object-Oriented Software". There's also an argument that strong typing is a form of tight coupling and antithetical to half of the Object Oriented axiom, "loose coupling, strong cohesion". Given the momentum in popularity that unit testing across multiple languages and development methodologies has (rightfully!) enjoyed, is it time to encourage language designers and programmers to move away from strong typing usage and substitute better testing practices?

The Design Patterns book is now over fifteen years old and it predates the Internet, Java, and XML, which is pretty amazing to me. However, it doesn't predate Smalltalk. Smalltalk is an influential and powerful dynamic object-oriented language. When working on the pattern catalog, we looked for known uses of our patterns in the Smalltalk libraries. If you study some of the pattern examples you can see how they can be implemented in Smalltalk. What is definitely true is that dynamic languages provide some interesting pattern implementation variations. I do not go as far as to say that static typing is in strong contrast to object-oriented principles. You can define loosely coupled systems in statically typed languages using interfaces and abstract classes. In addition, the more recent Dependency Injection pattern allows you to configure the dependencies of an object externally.



On the Current State of Academia? -- by eldavojohn (898314

I know a lot of people that are very vocal about what is right and wrong with education today. Especially college institutions: "No one teaches C, everyone teaches four years of Java, no one understands the theory, a CS grad doesn't even know what a model-view-controller pattern is." The list goes on. Since you have your doctorate and have probably spent a lot of time in research and academia, what's wrong with most computer science or engineering programs in general today? What would you like to see more or less of? Are there any subject directions recently taken (EJB, garbage collectors, interpreted languages) you'd like to comment on? You seem to be non-opposed to Java which, I'll admit, is rare to me for someone with a doctorate. I would like to hear your views since so often all I hear about Java is that it is slow and only good for people that want cheap software developed quick by beginner developers.

I cannot complain about the students that come out of nearby universities and that interview for positions on our team. Many of these students used Eiffel as their first language but they are all familiar with different languages using different paradigms. While they are not experts in EJBs, JFS, Dojo, Ruby on Rails or whatever, they have a solid CS background with lectures on patterns and are eager to learn. They come up to speed quickly with new technologies. This is required when joining a team like ours working on Rational Team Concert. For example getting started on the Rational Team Concert project requires a new team member to learn a mix of things such as Java, JavaScript, Dojo, CSS, C# (when working on the Visual Studio Client), Eclipse Plug-ins, REST and finally our agile development practices. One possible area of improvement is more familiarity with larger software systems and their architectures. Open Source project like Eclipse can serve as great study material. On the positive side I also observe that more students are starting to contribute to open source projects and can point to submitted patches in their CVs.

prostoalex writes "At QCon San Francisco, Aditya Agarwal of Facebook described how his employer runs its software stack (video and slides). Facebook runs a typical LAMP setup where P stands for PHP with certain customizations, and back-end services that are written in C++ and Java. Facebook has released some of the infrastructure components into the open source community, including the Thrift RPC framework and Scribe distributed logging server."

snitch writes "John Resig, creator of the jQuery JavaScript library, has released Test Swarm, a platform for distributed continuous integration testing for client-side JavaScript. Frustrated with traditional JavaScript testing environments that don't scale, John's new project, which is currently in private alpha, aims to provide a system for outsourcing browser-related testing to large groups of people or communities."

snitch writes "In a recent interview at QCon SF 2008, Tim Bray talks about why he is not convinced with the buzz surrounding Rich Internet Applications and shares his ideas on Cloud Computing. He also expresses his opinion regarding the debate REST vs. WS-* and the future directions web technologies will be taking. Bray also addresses the way web technologies are affected by the current economic turmoil and gives his insight into which paradigms he sees going forward in these challenging times."

snitch writes "Last week Mozilla released Bespin, their web-based framework for code editing, and only a few days later Boris Bokowski and Simon Kaegi implemented an Eclipse-based Bespin server using headless Eclipse plug-ins. With the presentation of the web-based Eclipse workbench at EclipseCon and the release of products like Heroku, a web-based IDE and hosting environment for RoR apps, it seems that web-based IDEs might soon become mainstream."

synodinos writes "The public draft of the Java EE 6 Platform specification has been published and will remain open for public review and feedback until the 23rd of Feb, 2009. Perhaps the most notable part of this delayed draft is the Web Profile, which is first profile in the history of the Java EE platform. The draft is available for download and contains both the Java EE 6 Spec and the Web Profile Spec. There is a poll running at java.net regarding what the community thinks about the new spec. Although participation is yet rather small the results tend to show that the released draft did not cause any excitement."

synodinos writes "Adobe has announced plans to publish the Real-Time Messaging Protocol specification, which is designed for high-performance transmission of audio, video, and data between Adobe Flash Platform technologies. This move that has followed the opening of the AMF spec has been received with varying degrees of enthusiasm from the RIA community."

synodinos writes "Adobe has announced plans to publish the Real-Time Messaging Protocol specification, which is designed for high-performance transmission of audio, video, and data between Adobe Flash Platform technologies. This move that has followed the opening of the AMF spec has been received with varying degrees of enthusiasm from the RIA community."

synodinos writes "Ola Bini, a core JRuby developer and author of the book Practical JRuby on Rails Projects, has been developing a new language for the JVM called Ioke. This strongly typed, extremely dynamic, prototype-based, object-oriented language aims to give developers the same kind of power they get with Lisp and Ruby, combined with a nice, small, regular syntax."