Apple has added a few language extensions for bounds checking, fat pointers, that would already help quite a bit. They are quite similar to Microsoft's SAL annotations used in Visual C++.

The advantage with Apple's approach is that by having this on an open source compiler like clang, there is an higher chance that the C and C++ communities adopt such extensions, and eventually make up to the respective ISO standards.

The relevant talks on security were:

• Recipe for Eliminating Entire Classes of Memory Safety Vulnerabilities in C and C++
• Adopting -fbounds-safety in practice
• C++ interoperability with memory-safe languages

I found quite interesting the approach they decided to take to talk about current state of security, with memory safe languages being islands, the amount of existing C and C++ code in the industry, oceans, and the interop layers between languages, the beach.

While trying to make use of Vercel Functions, it became somehow a challenge to understand how to deploy Node.js based application, using C++ Addons, as the documentation hardly touches this kind of deployments.

So after finding a way to actually make it work, by wrapping the C++ addons into a local package, which is then used by the rest of the application, instead of directly calling into the respective addon, I ended up pursuing an additional goal.

Namely that with the ongoing cybersecurity discussions, it would be interesting to check out the existing Go and Rust support for Vercel Functions.

In the end, I created a template project that basically provides Hello World kind of examples for Vercel Functions, written in pure TypeScript, TypeScript with a C++ addon, Go, and Rust.

There is also a configuration file for Swagger's online editor to make it easier to play with them.

Ready to be cloned, as basis to actually write proper production code.

• Go
• Rust
• C#
• Swift
• Java
• Ruby
• Python
• Delphi/Object Pascal
• Ada

For C and C++, the recomendation stands to the point, that if it is unavoidable to use them, then all kinds of analysers, hardware metadata are advisable to be taken into use.

Which leads to Google's recent report on security Secure by Design: Google’s Perspective on Memory Safety , which provides an overview on how Google has been improving their security in software development practices, and point of view on NSA's recomendation.

From the report, there is also a quite interesting blog post about C++ Buffer Hardening being done on existing code bases that cannot easily migrate to safer languages, by improvements on clang's libc++ standard library, and security features in clang as well.

It is quite pleasing to see programming language safety efforts finally making waves in mainstream computing.

Plenty of very interesting videos from .NET Conf 2023 are now available on YouTube to watch with great interest.

New C# and F# features, AOT improvements, united Blazor development experience, game development, machine learning, IoT, desktop and naturally cloud native development.

Definitely looking forward to project opportunities where .NET 8 might come into use.

On a similar note, CppCon 2023 started this week, Bjarne Stroustrup's keynote is already available, the subject being Delivering Safe C++.

Both touch on a quite relevant reality, that while greenfield projects should, or could, be written in safer system languages, there is a whole world of C++ code out there that isn't going to be easily rewritten into something else.

As such there should also exist tooling and development processes to improve the overal security of software projects, that for whatever reason still have to be written in C++.

Quite a pity really, I have expressed in the past my disappointment about its support, when Windows App SDK 1.2 was released, and previously how C++/WinRT wasn't a match for C++/CX.

Sadly this reveals yet another factor how Microsoft has been losing Windows desktop developers, has they have been continuously asked to rewrite their applications, only to be left with dead products in the end.

Thankfully .NET and Win32 are still around as the only stacks safe from this rewrite trendmill that doesn't seem to get right, what would be the next great UI framework for native Windows applications.

Other than that, picking cross-platform frameworks, or reaching out to the Web as alternative, are other possible sound alternatives.

During the session Default Security, David Weston from Microsoft, has shown the improvements regarding adoption of UWP sandboxing into regular Win32 applications, efforts to remove Admin requirements from several applications including Visual Studio (finally!), code signing, two levels of Admin access (similar to macOS SIP), and ongoing efforts to rewrite critical kernel subsystems into Rust.

This is great news for security minded folks, as memory corruption and other types of attacks are getting more seriously acknowledged.

However it is a pity that Singularity, Midori, Longhorn and to lesser extent UWP efforts aren't taking off as they should, with COM and Win32 still playing the central role on Windows development. One would hope that with .NET's introduction in 2002, and as shown on Apple and Google's platforms, COM would already been replaced by safer IPC, instead of still being pushed as the main extension mechanism. Specially as the existing tooling hardly does anything to improve security in COM development.

Nonetheless, it is refreshing to follow up on the ongoing security improvements, and Rust's adoption at Microsoft.

Back when I had the pleasure to join Intervento a couple of decades ago, the company was using Tcl for our application server. Built on top of a mix of Apache and IIS plugins, with the Tcl interpreter and plenty of extensions written in C.

Now writing JavaScript instead of Tcl, for Web development, while having the ability to write extensions, in a mix of native languages or WASM based ones, it kind of feels a bit like time traveling.

The main difference being that thanks to Node.js's advanced JIT, the need to write native extensions isn't as big as it used to be in Tcl's case.

It is so ironic how many ideas keep being rebooted all the time.

Naturally they keep using Java and Kotlin for userspace applications (I would rather have up to data Java support, but that is a subject for another day).

Additionally, since they added support for Rust about two years ago, most of the new low level systems code is now being coded in Rust. As per the article content:

In Android 13, about 21% of all new native code (C/C++/Rust) is in Rust. There are approximately 1.5 million total lines of Rust code in AOSP across new functionality and components such as Keystore2, the new Ultra-wideband (UWB) stack, DNS-over-HTTP3, Android’s Virtualization framework (AVF), and various other components and their open source dependencies.

Which is kind of nice, finally to start seeing managed languages, alongside safer systems programming languages being adopted into mainstream, no matter what.

Ironically, like in many other occasions, Microsoft could have been there first, had they decided to go commercial with either their Singularity or Midori efforts.

To a safer computing world.

While Microsoft's blog focus on what is new, I would rather summarize where the project is still standing since Project Reunion was announced in 2020.

Still no designer is available on Visual Studio that can match the tooling available for Windows Forms, WPF, and UWP developers.

The CsWinRT and C++/WinRT frameworks represent a big regressation in developer experience when compared with the .NET Native and C++/CX tooling available in Visual Studio.

The C# developers while using CsWinRT have to manually write export sets of API, invoke a command line tool, and then integrate the resulting build into the project, hardly modern when compared with .NET Native taking care for us under the covers.

The C++ developers, have to manually write IDL files, which to this day keep lacking Visual Studio tooling for code completion and syntax highlighting. They have to manually merge generated code into the existing project, master lots of low level details that the C++/CX runtime used to take care for us, hardly modern when compared with Qt/QML or C++ Builder offer to C++ developers.

The cherry on the already bad C++/WiNRT developer experience is that the team doesn't seem to care to improve it past C++17, so not even C++20 modules are planned for it, hardly modern.

The Windows 11 widgets just announced, require developers to use C++ and COM, just like in the old days before .NET. Hardly a modern experience when compared with Apple and Google developer experience to create OS widgets.

The recently announced support for AppNotificationBuilder, is only for C# developers. Those that are stuck with C++, have to write XML payloads as part of strings, parse it on the fly, before calling the notification APIs, hardly a modern experience.

The issues on the respective Github repositories for all projects just keep increasing.

After all this time, it looks like the team is fighting the last war, trying to make WinUI 3.0 reach feature parity with where UWP was in 2019, while Apple platforms keep improving SwiftUI, Google keeps improving Jetpack Compose, both using modern managed languages, with design tooling, without any messy C++ macros and bare bones COM, as if coding Windows UI from the last century.

Actually in that sense, Windows Forms, WPF and even MFC, are more modern in developer experience than Windows App SDK 1.2 is capable of

One set are the KataOS and Sparrow OSes being built on top of the seL4 microkernel for secure embedded development.

Another one is an unikernel project from the RWTH-Aachen university, that besides being written in Rust, it allows the packaging of C/C++/Go/Fortran applications into unikernel deployments.

In the C++ community there is a famous talk from Dan Sak about C++ advocacy for embedded developers still focused on the ways of C, where at a given moment he states "If you're arguing, you're losing.".

That is indeed a much better approach, writing C++ with safety knobs all turned on, or using compiled managed languages, for tasks that people generaly consider not possible and thus proving them wrong with hard facts of acceptable performance.

Unfortunely not even that might change some minds, but if there is at least one person changing, that is already a victory.

Changing the world one small step at a time.

While you will need to wait until the end of September to get the dead tree version of the book, the ebook is already available if you want to get it right away.

It has been updated for C++20, also contains some C++23 related content, and just like any other Bjarne Stroustrup's books, a pleasure to read.

Already reading my copy :).

Sadly it seems that these years in between have hardly brought any improvement in this regard, other than Microsoft acknowledging in their March WinUI Community Call that this is indeed a common complaint.

Common or not, it is quite clear looking at the updated roadmap, that improving such tooling will be very low priority and if it comes, it will be late 2023.

When we look at the public activities across WinUI 3, AppSDK, C++/WinRT, CsWinRT, Rust/WinRT repositories on Github, one must question where are the teams, as it seems they are clearly underresourced with very low commits per day.

So not only do C++/WinRT users have to wait a couple more years for an experience that they can enjoy today in competing development stacks, the overall future of WinUI as alternative to classical Win32 based development keeps unclear, with many Microsoft teams migrating to Web technolgies instead.

Sometimes I wonder how product management decisions take place.

For that purpose I have ported my old A* demo application into a full UWP application, dropping the platforms that no longer make sense to me (Android/Windows Phone).

It was a kind of, lets say, interesting experience having to deal with all module support bugs in the compiler until all pieces of the puzzle finally reached a stated where I can take advantage of modules on my C++ code.

I have updated the project readme to describe some of the hurdles that still persist in Visual Studio 2019 v16.15, however to make it easier on the readers, I am also listing them here:

Although there is still some work to do, specially some leftovers to fix after the remaining issues get resolved, it is with great satisfaction that I finally managed to use C++ modules after so many years following their development at ISO C++, and major C++ compilers.

Kudos to everyone involved and looking forward to a modules world in the C++ ecosystem

For starters there are lots of performance improvements across all File IO APIs.

Several comunity contributions, including C like memory management APIs as replacement for the MarshalInterop ones.

Finally for the overall performance overview, better grab a long coffee, or beer, as it is a very lengthy but very worthy read, of how performance has been improved across all layers of the runtime.

Unfortunely AOT seems to have been partially improved, with full support postponed for .NET 7, so it isn't this the release that will catch up with Delphi, or the already existing .NET Native, but I guess we always have to have something to look forward on upcoming releases.

Anyway, plenty of stuff to play with when .NET 6 finally reaches GA and we can use it in production.

The announcement post described plenty of upcoming goodies, namely ongoing unification, MAUI, AOT with PGO support, .

Lots of deep explanation and details about what to expect from .NET 6, this year's BUILD might look like quite interesting, regardless of the constraints of ongoing conferences.

As described by the blog post at the Red-Hat developer's blog, it checks potential memory leaks and memory corruption issues, at compiled time.

The best security measure to avoid security exploits in memory unsafe languages like C, is to avoid to use them as much as possible.

However given that this is not possible, for example in IoT and UNIX like kernels, then it is great that such tools are available to help developers writing safer code in languages like C.

So don't forget, when using C from GCC 11 onwards, -fanalyzer -Wall -Werror.

The initial version supports C#, Rust, with a modern C++ version on the works as per their annoucement post.

Kenny Kerr, responsible for C++/WinRT development, and nowadays leading the Rust/Wint effort has additional details on a post of his own, specially the introduction which I am quoting below

I am excited to finally talk about the grand plan we have been working on for some time, namely the unification of the Windows API. No more Win32 here, WinRT there, COM this, UWP that. Just stop it.

Reading between the lines I am seeing several endevours at play here.

Rust's adoption at Microsoft keeps increasing, and we shouldn't be surprised it eventually makes into Visual Studio installer.

By focusing on C#, Rust and modern C++, Microsoft is adopting the programming language selection approach suggested by Microsoft Security Response Center.

Other .NET languages, might have to lean on C# bindings, but that is anyway not an issue on the CLR, given its original design.

A plus note on the C# generated bindings, Microsoft is using DirectX for some examples, no doubt due to the endless complaints from many of us how the managed developers were dealt by the DirectX team.

Finally, it also shows yet another milestone from Project Reunion, merging the UWP and Win32 worlds back into one Windows.

Whatever might be announced at BUILD 2021, is starting to look interesting.

The article is available at the usual place in Project Zero's blog.

Maybe recurrence of similar exploits will help to steer Apple into focusing more heavily into improving Swift for systems programming, instead of relying only in C, Objective-C and C++ for low level coding.

This week's .NET Conf 2020 contains several talks about all these features.

Also, happy birthday .NET, it has been 20 years improving developer lives.

I tend to be quite critic of the security issues cause by applications written in the C programming language, as such I was quite supportive of Microsoft's decisions not to pursue C compatibility on their Visual Studio compiler suite.

However after my previous critic of, it so happened that at CppCon, Microsoft just announced C11 and C17 on the upcoming MSVC version.

I also noticed that the User-Mode Driver Framework, which was introduced as a C++ COM library, was rewritten in C for the version 2.0.

So this alongside their newly found Linux love, means me not getting it, and better spend time advocating on how to write better C code instead. It isn't going away on the Windows eco-system, apparently.

Moving on to Go, another language that although I like many of its ideas, its lack of generic support has always put me off.

Well for better or worse, thanks to projects like Docker and Kubernetes, and the cloud development platforms built around them, it means that even if one's favourite language is something else, sooner or later, one needs to dive into some project written in Go.

So wrong again, anyone in the DevOps space is doing themselves a disservice not having at least a passing knowledge of Go, generics or not.

Finally, I really like UWP, after its clunky start in Windows 8 and Windows 8.1, when Windows 10 came around the whole programming model was finally merged across all kinds of Windows deployment platforms, and .NET Native really felt how .NET 1.0 should have been all along.

However as Reunion keeps to shaping up, and parallel discussions about .NET 5 on desktop vs UWP, C++/CX vs C++/WinRT tooling, .NET AOT, it is starting to feel like Project Reunion will just reboot everything back into Windows 7 kind of developer stack, with a couple of UWP goodies thrown in, and every else UWP related will just be quickly forgotten as a bad dream.

So third time wrong, UWP really isn't the reboot that would actually change Windows development as I hoped for.

Naturally given its underlying nature of being based on an UNIX like kernel, written in C, meant that several exploits due to memory corruption, double frees and NULL pointers, were quickly found out, despite its sandboxing model.

The bug fixes for those exploits have now been released as part of Azure Sphere 20.07 Security Enhancements.

The takeway is that anyone that is security conscious should avoid platforms that require C as their main development language. Even Azure Sphere with all its sandboxing and adverstised security wasn't able to survive a red team attack on the platform.

Using managed languages, or system languages like Ada/SPARK and Rust are the way to go for security conscious developers.

Or maybe this is the final drop to make Checked C finally available out of MSR, or bring some wind into Project Verona, but those are themes for other blog posts.

For those not in the known, Visual C++'s lifetime checker was introduced by Herb Sutter at his talk Writing Good C++14... By Default presented at CppCon 2015.

Later he has provided more information about the current state, and the Lifeme Profile for C++ Core Guidelines on his blog.

So given that Visual C++ has support for the lifetime profile on its Core Checkers static code analysis, I decided to have a go at it with the newly rejuvenated A* Demo codebase.

I have to say that I ended up having mixed feelings for the current state of the lifetime checker. While it does indeed help prevent many of the traditional C and C++ memory corruption issues due to pointer lifetimes, it also generates lots of false positives.

I ended up reporting some of the false positives myself, or if they aren't false positives and the code is indeed incorrect, the error messages are inconclusive and don't guide the developers to the possible cause of the lifetime management error.

So good idea to make C and C++ safer languages, after all 70% of security bugs are caused by such issues as per recent reports, but still far from what languages like Rust and Ada/SPARK are capable of regarding lifetime management.

The result is now available in the A* Demo section.

It was an interesting experience, but now I rather focus on .NET 5, C#/WinRT and Project Reunion, as announced during BUILD 2020.

On the .NET eco-system Microsoft just announced the preview release of C# Source Generators, which allow for metaprogramming during compile time.

It is yet another tool for our code generation arsenal in .NET, alongside reflection, T4 templates, expression trees, F# quotations and type providers.

Actually it is based on the same ideas from F#'s type providers, but applied to C#. Speaking of which, while unfortunely there are no plans to support VB.NET for the time being, they are open to suggestions to add a similar capability to F#'s compiler toolchain.

Another good news was the release of the ownership/borrowing system for the D programing language.

This is the first step to integrate lifetime analysis capabilities to D, alongside its GC support, thus bringing one more tool for dealing with memory management into the box. The link above contains a very good description of the initial prototype and what are the main goals for the feature.

Finally, after a couple of complains from my side regarding the use of Rust on Windows, I have to humble bend to the Rust community and the achievements at Microsoft.

Not only did the Microsoft Security Response Center publish an article about they are using Rust and Kubernetes together, as they used Rust to implement Krustlet, an engine to execute WebAssemly on Kubernetes pods.

They also announced the first public release of Rust/WinRT.

Naturally these are the initial baby steps, but there is hope that eventually we get Rust/WinRT on Visual Studio alongside the other projections already supported for UWP/WinUI.

So all in all, lots of very interesting news.

So for starters I went to MSDN, which has quite a rich set of documentation regarding C++/WinRT.

Given that my focus are graphical interfaces, I decided to follow along with their Bookshelf tutorial.

So while it appears that C++/WinRT has come a long way since Microsoft decided to adopt the initial project, it still needs to evolve quite a bit to match C++/CX tooling on Visual Studio.

Some of the issues that I find that downgrade the C++/CX developer experience while using C++/CX are:

• Midl files have to be manually taken care of, while C++/CX just handles them for us;
• While we are forced to edit them manually, no support is provided in form of syntax highlighting or Intelisense;
• We are forced to manually copy generated code from Mdil compiler output into the respective translation units;
• Making use of {Binding} requires manually adding more boilerplate;
• For whatever reason, the team is quite into east const, so we get it everywhere now;
• I thought Hungary notation was gone, apparently the examples are keen in using stuff like m_ prefixes, as if this did not exist.
• Even Microsoft libraries like Win2D have integration issues with C++/WinRT.

Given its current state I would rather advise Windows developers that have C++/CX codebases to keep using it, and regularly check on C++/WinRT tooling improvements, if any.

As it stands it feels more like a downgrade on tooling experience, with plenty of room for improvements.

Althought it is kind of debatable what Modern C++ is all about, one thing that most in the community agree with, is taking advantage of the abstractions and improved security options that C++ brings into the table versus bare bones C.

As such the Awesome Modern C++ is a very good list of resources.

The talk was quite interesting, and the system is already quite mature, given the examples demoed at the end of the talk.

Naturally, I also updated my safe systems overview regarding bare metal implementations in Go.

Interestingly the author has chosen the same name as the Modula-2 based OS designed by Niklaus Wirth, however they are unrelated.

In any case, I ended up updating again my safe systems overview with this new OS entry, hoping that the safe systems trend continues.

Also updated my safe systems overview with the Google IO 2019 talk regarding on how Google is making use of Go and Rust to provide a sandboxed enviroment to run GNU/Linux applications on top of Chrome OS.

The reasoning behind it is explained on the blog, and it boils down to the fact that even with all the hardening efforts that have been done up to Android 9 (Pie) release, half of Android security exploits are still related to memory corruption in C and C++ code.

Given the success Solaris enjoys with similar hardware assisted pointer validation, there is some hope that at least in the context of future Android devices, the security of C and C++ code improves drastically thanks to such measures.

• Project Valhalla (value types);
• Project Loom (fiber support);
• Project Panama (JNI replacement with something more developer frindly);
• TornadoVM (running Java across CPU, GPGPU and FPGAs);
• Vectorization support;
• AOT compilation across OpenJ9, Graal and OpenJDK VMs;

Lots of interesting issues being debated, regarding the ongoing project status it appears that in spite of all research, and prototypes that have been developed throughout the years, we might still need a couple more until they finally land on a public JVM implementation.

Regarding AOT compilation, it appears that while it brings a huge improvement for application startup, it still has some compromises regarding language features and peak performance from advanced JIT implementations. So the trend being having a mix of AOT/JIT, with each other helping the other one doing its work. For example, caching generated JIT code and re-using it as AOT for the subsequent run.

So if any of those themes are of interest to you just head up to the videos playlist, and enjoy a couple of talks done by some of the brightest minds in the Java ecosystem.

The Lisp supported by the board is uLisp, a well known Lisp variant for microcontrollers.

Happy New Year for 2019! All the best for you dear reader, friends and family.

Quite glad to see that happening, lets see what the .NET open source community does with such oppportunity.

More information about it at the .NET Blog.

A very interesting read for all Java developers. My favourite ones are local type inference and the continuous improvements related to Graal integration.

Besides the well known feature of modularization, I am looking forward to the introduction of a linker and the inital support for AOT compilation, to be further improved on Java 10 onwards. And of course the introduction of Graal support.

As graphical focused developer the JavaFX improvements related to Gtk 3, HiDPI Graphics, Merlin renderer, TIFF support are also quite interesting.

Already migrated all my Java 9 beta installations to the final release.

Now only have to look forward to the day it will eventually come to Android, hopefully faster than Java 8.

As it turns out, there is actually a new project called GAPID, which is supposed to be the successor of the GPU debugging tools.

However it was just a pile of source code, forcing everyone to get all the required tools to build the application and integrate it into the development workflows.

I have been recently contacted by the GAPID team to let me know that now they are generating binary packages for all three major desktop OSes.

So I got to download the variant for Windows, tried it out on a few OpenGL ES examples and must say it worked quite well.

As I was preparing to write this blog post, I have also noticed that now the GPU trace documentation also has a reference to GAPID.

So looking forward to improvements on the tool, and maybe now I can start playing with Android Studio 3.0 Canary as well.

As closing note, congratulations to the team, and I wish they get the necessary support from within Google to keep driving this project forward.

I am a bit late with this information, as they actually announced it last month. It consists of three new projects, two of which in Go and one in Rust for dealing with GNU/Linux containers.

Starting with Visual C++ blog where they have a nice post entitled Security Features in Microsoft Visual C++, about all the compiler and library features they have for writing safer C++ code.

Mozilla shared how they managed to make all warnings compile as errors across such a big codebase like Firefox, thus reducing the surface of possible exploits caused by unsafe code.

Finally a few well renowned researchers, namely Pascal Cuoq and John Regehr, have written yet another article about the dangers of undefined behaviours (UB) in C and C++.

A very interesting article, with an overview about the about 200 UBs that currently exist across the C and C++ standards, many of which not yet managed by modern sanitizers.

Quoting the last sentences of their conclusion:

Be knowledgeable about what's actually in the C and C++ standards since these are what compiler writers are going by. Avoid repeating tired maxims like "C is a portable assembly language" and "trust the programmer".

Unfortunately, C and C++ are mostly taught the old way, as if programming in them isn't like walking in a minefield. Nor have the books about C and C++ caught up with the current reality. These things must change.

Basically C and C++ developers are like sushi masters dealing with very sharp knives, and learning when to put those metal gloves does come in handy.

Last week's Cloudflare parser bug, appropriatly named Cloudbleed, is a good example why it is about time to stop plugging C code into the network.

Once more we had a large scale exploit caused by a buffer overrun, as it typically happens in C code.

At this point it is good to recall C. A. R. Hoare's lecture at the moment of his Turing award back in 1981.

The first principle was security: The principle that every syntactically incorrect program should be rejected by the compiler and that every syntactically correct program should give a result or an error message that was predictable and comprehensible in terms of the source language program itself. Thus no core dumps should ever be necessary. It was logically impossible for any source language program to cause the computer to run wild, either at compile time or at run time. A consequence of this principle is that every occurrence of every subscript of every subscripted variable was on every occasion checked at run time against both the upper and the lower declared bounds of the array. Many years later we asked our customers whether they wished us to provide an option to switch off these checks in the interests of efficiency on production runs. Unanimously, they urged us not to - they already knew how frequently subscript errors occur on production runs where failure to detect them could be disastrous. I note with fear and horror that even in 1980, language designers and users have not learned this lesson. In any respectable branch of engineering, failure to observe such elementary precautions would have long been against the law.

So almost 40 years later, we keep using languages that don't provide any mechanism to do bounds checking other than relying on external tools, that the majority of the community tends to ignore.

For anyonet that cares about security, C should be relegated to the same though process as Assembly, using it just where no other alternative is viable, e.g. UNIX like kernels, or very tiny microcontrollers, for anything else there are better, safer languages with compiler toolchains that also allow for AOT compilation to native code, including the creation of dynamic libraries.

A not exhaustive small list of such languages could be:

• Ada;
• ATS;
• C++11 onwards (modern style, not using C like language features);
• C# (via .NET Native);
• D;
• Delphi;
• Free Pascal;
• Go;
• Idris;
• Java (via ExcelsiorJET, J9, JamaicaVM, ...);
• Nim;
• OCaml;
• Oberon-07;
• Rust;
• SPARK;
• Swift;

Even on APIs that require a C interface for wider FFI acceptance, a safer alternative is to make use of one of the above languages for the implementation and then provide C like entry points

Of course on scenarios that really require C, like UNIX kernels, given their interwined relationship. Or microcontrollers where even using Assembly is a challenge regarding code size, at very least the tools and processes that help tame C, like warnings as errors, static analysers, code reviews, CPU bounds checking (e.g. Intel MPX), fuzzing, among others, should be part of the overall development process.

Right now my focus is going through the already available set of presentations and videos.

Videos are coming up slowly on YouTube, but the ones already available are quite good:

• Bjarne's The Evolution of C++ Past, Present and Future;
• Rich Code for Tiny Computers: A Simple Commodor 64 Game in C++17, for those nostaligic about the C64;
• Building up on that talk, Dan Sak's extern c: Talking to C Programmers about C++;

Dan Saks talk was quite entertaining, specially when coupled with Jason Turner's talk. Although C++ does suffer from the same ways to write insecure code as C, due to its language compatibility, it does provide lots of improvements for writting safer code with zero overhead abstractions. So transitioning to C++, while taking advantage of said features, would already be an improvement in our actual computing stacks. The problem is getting the message through.

And if those developers don't believe in C++, let alone switching to something like Swift, D or Rust unless it gets imposed on them.

As mentioned the slides are also available and you can get most of them from Github'a repository.

Kenny Kerr also presented his work at Microsoft on replacing C++/CX with standard C++17 features, with the current name of C++/WinRT as framework name, and the related slides are made available on his web site.

Going back to the presentations, there were quite a few interesting ones related to functional programming in C++, use of algorithms and type safety, removal of deprecated features, heterogenous and parallel computing, IoT and C++'s use on the games industry.

I am also looking forward to having Herb Sutter's talk available on YouTube, as he was presenting best practices to take advantage of automatic memory management in C++ and a new library for deferred reference counting.

• Microsoft fired another set of employes working in Windows Phone teams;
• Amazon announced they would drop their WP app;
• The former Nokia Here Maps, also dropped the platform;
• Microsoft's own Skype, dropped support for 8.x yet it keeps XP support;

So it was quite fun to develop some proof of concept applications for the Windows Phone 8.x with C# and C++/CX, but given all these changes it is quite obvious that the future of UWP is everywhere but the mobile space.

It will surely thrive on the desktop, hybrid laptops, HoloLens and XBox, but I very much doubt that there is any life left on mobile phones for it.

As such I have been focusing only on Android and to finish with a positive note I was quite happy to find out that the upcoming Android Studio 2.2 has a much improved support for C++, specially the new integration with CMake.

Although Google doesn't state it officially, it seems that ndk-build and the Gradle experimental plugin might eventually both be deprecated and replaced by the newly introduced CMake support.

There are lots of interesting talks available, the ones I have found most interesting were:

• Bits of Advice for the VM Writer
• Building High Performance, Fully Concurrent Garbage Collectors
• A Concise and Opinionated History of Virtual Machines

The talks were full of juicy technical details about implementing VMs and improving their performance.

Also the NDC conference organizers just release their videos and the ISO C++ web site has a list of all the C++ related presentations.

From those ones I personally have enjoyed:

• The ones from Andrei Alexandrescu as always
• The C++ Type System is your Friend
• Using the C++ STL Without Dynamic Memory
• The C++ and CLR Memory Models, quite interesting for anyone doing multicore programming.

The best news for those of us that spend most of our time on Windows is the integration wiht the Visual C++ tooling, instead of relying on the MinGW/MSYS2 toolchain.

Time to update the current installation.

Looking forward to the presentations regarding the modules work in Java 9, the value types and improved native interoperability targeted for Java 10.

They presented the C++ Core Guidelines a set of guidelines for using C++ well, focused on writing safe code.

Currently the main focus was on memory safety, but more areas are planned like e.g. concurrency.

The guidelines are written in a way that they can be enforced by either a compiler or a static analysis tool. Herb Sutter and Neil MacIntosh demoed the prototype that Microsoft is planning to deliver with Visual Studio 2015 Update 1.

One of the most interesting outcomes from the guidelines is that C++ community is aware of the work being done on Rust and see affine types as a way to improve C++'s safety. However instead of making the language even more complex, the plan is that the same type of ownership rules can be validated with help of a guidelines validation tool.

As someone that likes memory safe languages, I admire the work the C++'s community is putting on safety.

The main focus were performance and improving Windows support, which should be fully done by the 1.4 release.

• Bartosz Milewski. Categories for the Working C++ Programmer
• Mikhail Matrosov. C++ without new and delete

Both talks are about themes that bring modern C++ forward in terms of explaining how to enjoy memory safe programming, even if the language is unsafe by default. And also how to enjoy functional programming in C++.

The presentation language is English.

Metal is now available on Mac OS X as well and all the accelerated rendering frameworks that were built on top of OpenGL have been migrated to use Metal instead. This might be the start of OpenGL dismissal on the Apple platforms.

I doubt now that Apple will spend any effort improving OpenGL support or adding Vulkan support on their operating systems.

So in a twist of irony, the same company that rescued OpenGL from being ignored by game developers, by including it as the iOS 3D API, decides to replace it with its own API.

Android migration support will be support be done via Project Astoria, while iOS support will be provided via Project Islandwood.

While both share the common goal of running other OS applications as Universal Windows Applications, they offer different levels of integration.

Project Astoria will offer Android compatibility inside of a container environment, a kind of Windows Android Runtime, even if the example is a bit stretched.

Whereas the Project Islandwood, will make Objective-C a first class language in Visual Studio, offering the same OS access level than C++ enjoys.

In any case, it seems that Microsoft might be trying their own version of the OS/2 compatibility that ended up killing the OS.

While it is clear the OS needs a big push to make it relevant for the developers, I am not sure if it was a good decision, given how similar attempts have continuously failed at it.

The slides are already available from the respective talks that are listed on the conference's schedule.

The non edited videos are already available on YouTube for those eager to watch what happened at the conference:

• Day 1, afternoon
• Day 2
• Day 3

Better versions will be later posted. Just watch out the D programming language website for the news.

Some of the more interesting ones for me were:

• How D is being used to implement a storage system.
• A case study about D being used for Hedge Fund development
• Chuck Allison 's talk about his transition from C++ to D
• Andrei Alexandrescu's talk about the new allocators coming to D

Just hop into the web site, as there are quite a few interesting ones, besides those.

It was an interesting experiment, combining Java and C++ on the Android side and C++ with C++/CX on the Windows Phone/Store side.

Althought the application isn't fully productified, the goal of understanding the effort of writing portable applications without additional third party libraries has been achieved.

For companies targeting multiple platforms, Qt and Xamarin are really the best way to go native. Qt has improved a lot since my last rant. The effort to add aditional native wrappers is smaller than the whole development process.

However for single developers, it might be better to focus on single platform. Those portability layers add up an extra cost to the whole development process, specially in terms of extra wrappers and debugging, which might be too costly for single developers.

All in all, it was very rewarding experience.

The final result is now available on the web site.

Quite a different language when compared with the original design, still it was for the better.

I am looking forward to see how its adoption is going to turn out.

Congratulations to everyone involved in making it come true.

He goes over the process of adapting what are originally imperative OO algorithms into functional ones.

Quite interesting to watch for those thinking about moving over from Objective-C into Swift, specially how to adapt multi-paradigm languages.

The date of a 1.0 stable release is now 6 weeks away, according to the current plan.

I wish Rust becomes mainstream, as a way to increase the set of available ML based languages to choose from.

An interesting idea of following a multi-step tutorial on how to implement a Clojure inspired Lisp interpreter proposed by Joel Martin.

If you are into programming language development, just clone the Github repository, pick your favourite programming language and have a go at the implementation guide.

Another step closer to having version 1.0.0 ready for prime time.

Really looking forward to have another modern alternative for systems programming.

This is really great. Now besides having Mono as alternative implementation for .NET, we have the platform owner bringing to reality what was discussed a few months ago about embracing the .NET community across platforms.

Nowadays I really enjoy the platform and have lots of fun developing C# and F# applications on it.

Quite funny to lock back to .NET early days, which I was priviledged to take part on, thanks to the company I was working at the time being a Microsoft Partner.

Like many Java devotees, I loudly complained about .NET being a flagrant copy of Java.

Fast forward almost 15 years and while both platforms still share a lot of concepts and frameworks, they are quite different nowadays.

And my opinion also changed, regardless of the business reasons behind its inception, .NET is a very good platform to develop software on, and .NET Native will make it even better.

So it is quite pleasing to see Microsoft sharing .NET with the world at large, and with it, allow developers outside the Windows eco-system to also be able to deploy .NET based applications on their platform of choice.

Have a look at them, they make quite a good use of Modern C++ features.

There are libraries for a LINQ-like usage, unit testing, JSON parsing, image processing, safe string formating, reactive functional programming and many others.

This is great signs of the progress done by the Rust team. As for the previous versions still had a few issues to be installed into Windows and specific mingw versions.

Finally I am able to play with it on my work laptop. Sweet!

The videos are now available at YouTube and the slides at Github.

Some of the best talks were related to the use of modern C++, meaning to use the C++ collections library, RAII and automatic memory management. C like coding should be left the the few cases where every performance increase counts.

Now that C++ has lambdas, a few of talks were also focused in functional programming, which was quite interesting to see the community embracing functional programming, specially given that <algorithm.h> already exists since C++98.

An interesting talk to get to know the point of view of the gaming industry about C++ was Mike Acton's talk about data oriented design and its use in game development. Althought I don't agree with some of his points of view, his talk is quite interesting.

All in all, modern C++ is looking quite good and I have to conceed a few of my old complaints are no longer valid when compared against C++14.

As it usually happens in what we, software developers, consider a simple task. It ended up taking more time than expected with disapointing results.

The first issue was the size. 40 MB is just too much for a simple window that renders a map with the respective path, if found. Specially when targeting devices where space is at premium.

Then came the first showstopper. When I tried to deploy the application to Android, the file dialog that gets shown is a standard desktop one. Impossible to use in tiny screens and completly out of place in Android.

The current Qt version is 5.3 and apparently the upcoming 5.4 will sort out this issue. But only when using Qt Quick for the UI as pure Qt/C++ seems to be on the way out.

I pondered to write a file dialog myself, but that would beat the purpose of using a multi-platform toolkit in first place.

So in order to prepare the application for the updated controls, a rewrite was in order. Which led to more wasted time as I tried to understand the differences between the initial QML version and the current one, how to recode the C++ widgets to be usable from QML and fighting the QML editor that had some issues seeing the latest changes from the C++ side.

This also added the complexity of having yet another layer in this portability sandwich. In order to work around an usability problem, not only did my program had to deal with the C++ and Java interactions. Now it also needed to take care of Qt Quick (JavaScript) and C++ interactions.

After the re-write was finished and working properly on the simulator, it was time to deploy it into real devices. Only to be greeted by an empty white screen!

So in conclusion, my Qt experience was a failure. With the amount of time I lost fighting these issues, I could have implemented an Android and Windows Phone UIs using their native supported languages instead. And the overall UX that I could provide would be much better.

Which was in fact, what I ended up doing. Ditching Qt and a final re-write using only the technologies provided with the mobile SDKs.

Sometimes too much abstraction hinders, instead of helping.

According to Herb Sutter is was a very good conference as C++11 and C++14 standards really brought a new life into the language. Thanks to the missteps of other language vendors, currently C++ is the only language common to all mobile SDKs.

There were lots of talks about modern C++ and also from the gaming industry.

Just take the presentations while they are still hot.

The new C++14 got released and I just recently got to check it.

This is another step improving the language in terms of safety and modern paradigms. Still looking forward to eventually have lite concepts and modules support, but that is only planned for the next revision.

While C++ is not Ada in terms of safety, C++11/14 does improve a lot the ability to write safe code when the corresponding language abstractions are taken into use.

Michel Wong does provided an C++14 overview on IBM's C/C++ Cafe

Now lets see how long all major C++ compilers take to achieve full compliance, on desktop, server and embedded platforms.

I like how Rust is evolving towards the 1.0 version.

I just found about it now and was quited pleased with the interview.

Their approach in using a functional programming language like OCaml for operating system design, with emphasis in correctness and security is the way forward for operating system design in the 21st century.

Nowadays we have stagnated with lots of UNIX clones, and approaches like this are commendable, by trying to improve the operating systems architectures. Specially by proving it is possible to use a language like OCaml for such tasks.

Without further ado, the interview is available here.

The language has a certain ML feel to it, my favourite features being:

• Descriminate unions
• Pattern matching
• ML type inference
• Extension methods
• Generics
• Automatic memory management
• Value types
• Memory safe

The associate tooling also has some relevant features:

• AOT compilation to native code (really like how Apple favours AOT over JIT)
• REPL with an interactive storyboard for exploratory programming
• Objective-C interoperability for code reuse

I am looking forward to see Swift take Objective-C's as the main programming language in the Mac ecosystem. It might not be Dylan, but it is quite close.

The article has been updated accordingly. Many thanks for the given feedback.

• Build Your Own Lisp for Great Justice, by Bodil Stokke.
• My other operating system is a Mirage, by Anil Madhavapeddy.
• Railway Oriented Programming, by Scott Wlaschin.
• Programming, Only Better, by Bodil Stokke.

The first three talks are located at Skills Matter and require registration to watch them, but it very worthwhile.

Quite interesting seeing functional programming finally becoming just one more tool in our toolbox.

It is a port of an old exercise initially done in C with OpenGL 1.1. back in 1999, to two distinct modern platforms.

The Web, via JavaScript with WebGL and ThreeJS libraries.

The native mobile world, via C++11 with OpenGL ES and SDL 2.0, only Android was tested thus far.

The main goal was to refresh a bit my OpenGL knowledge, while a the same time having some fun both with JavaScript and C++.

The point being made, is how more productive and coherent languages like Lisp, Smalltalk, Beta, Newspeak were, and how they failed to impress the average developers, due to the hard time innovators have changing the present mindset of how things should be.

Most so called modern languages, are actually rediscovering what these languages offered in terms of features and tooling, but usually done halfway. Which only offers a kind of experience, when compared how it use to feel using such functionality.

So language designers should look properly look into the past, when designing the experience of the programming languages of the future.

Very interesting talk, as Gilad Bracha always does.

In order to keep up the trend, there was a presentation at Clojure TV about the use of Nanopass as compilation technique for Chez Scheme.

The main idea behind it, is to design the compiler passes in such a way that they are composed by very small passes that are then plugged together. In comparisasion with traditional compiler passes, it allows for a more modular development of such passes.

Since then, I have been spending time around D and Rust communities.

I also started to follow the work being done at Cisco with OCaml safe systems programming.

Meanwhile, Go has been taking up speed by many startups, mainly by developers that consider Go's simple design as a positive feature and not an impediment as I and others see it.

Currently, at least dynamic linking, dynamic loading are being working on and there is a way to fake enumerations with const groups.

Given that the uprise in any safe compiled language should be actually considered a good thing, I think to carry on discussing about generics in Go is a waste of time.

Most likely they will never come. So instead of wasting energy discussing it, better to spend time contributing to any FOSS project, even Go.

As a concluding thought, if you are planning to write any application in C and Go's simplicity is attractive to you, I would advise to try to prototype it in Go.

You might never come back to C afterwards.

Maybe because of it, as most of those projects tend to have a mix of spaghetti code composed of scattered JavaScript, CSS and HTML hacks, as a means to work properly across all required platforms.

This is just plain wrong, when compared how simple it is to handle layouts and components in native frameworks and older systems like HyperCard or Smalltalk.

However, regardless of how one thinks about it, the industry is going more and more into the HTML 5 direction, so the best way it to adapt rather than being left behind.

So I was rather pleased to discover AngularJS, as it seems to bring a bit of native code development sanity to the web.

I will surely be playing quite a bit with it.

While I don't agree with everything that is said on the article, specially in regard to D, I find it very positive that a teacher decided to pick up a safer language for systems programming besides C.

We need safer languages for systems programming and new generations are usually unaware that there were operating systems developded in other programming languages, besides C. And being safe does not mean requiring a VM runtime.

C++ does improve lots of defiencies about C, specially when using C++11/14, coupled with STL, but the C underpinnings of the language are the Achilles ankle in security.

Who knows, maybe sometime in the future we will have a mainstream OS developed in such language.

Apparently it is based on the same backed as Visual C++ and they are planning to bring all the optimization goodies from their compiler into .NET land.

This are quite good news, given that Microsoft hasn't invested that much on their JIT compiler in the last .NET releases in terms of automatic vectorization of code, access to SIMD operations and similar optimizations.

It is full of worthwhile content about C++'s use in the industry, specially what is nowadays currently known as Modern C++, thanks to the use of C++11 and C++14 constructs.

For a graphics loving guy like myself, the informations about openFramewors and Cinder C++ libraries was also quite interesting!

Myself I am currently looking into Cinder. :)

Very worth a look, specially if you think you are quite confortable with C and C++.

In case you enjoyed the presentation and want to improve your knowledge about it, there are some slides available at slideshare. Take care of preparing some coffee as the presentation is quite long (445 pages).

If you still not know much about Clojure, it is very worthwhile to spend one hour of your time getting yourself acquainted with the wonders of Lisp based languages.

Even with my complaints about how C and by implication C++ tend to be insecure, C++ is a powerful language that I always enjoyed exploring. Even using it as my main language in some of the jobs I worked on.

Therefore I have been salivating for the new version, waiting for Bjarne Stroustrup to update it for the C++11 standard.

The new edition is full of updated examples how to use modern C++, coupled with learnings how C++ evolved since C++98 standard, it will surely be an interesting reading.

The document goes over the process of implementing a Scheme subset compiler in Scheme itself using an easy understandable way.

If you are looking to learn how compilers work, this is a very nice tutorial and I advise you to give it a shot.

The main issue being that it was developed back when Java initially released, and it was relying in quite a few compiler bugs that have since then been fixed, thus making the code not compilable.

So I ended up porting the build system from a bunch of Makefiles into Maven, replacing the code which I didn't have distribution rights by a new runtime written in Assembly and taking advantage of new Java 7 features.

Just head up to the L98 project area for the new version.

Lots of nice stuff for developers with interest in compiler design.

I find it very interesting, because although C and Assembly still rule this space, Ada is a much better language in terms of safety to develop applications on.

The reliance on C for application development is a path full of security holes unless you couple your development with warnings as errors compiler options and static code analyzers that bring C to the same safety level enjoyed by default in languages like Ada.

I will be interesting to see how Ada's adoption might improve in this space.

In the process I removed a few C style code parts by their MFC code, as now MFC offers better ways to write similar algorithms.

Always a good excuse to improve code quality.

The application is the already known Hilo sample, that Microsoft also used when Windows 7 was launched.

Finally someone is making some effort to allow Java developers to target native code compilation on iOS devices. It still surprises me that although many Java vendors do provide ahead of time compilation for their Java enviroments, Sun and now Oracle don't provide them.

This leaves many developers with the wrong idea that there are only VM environments for Java, when actually that is not the case.

I wish all the luck the RoboVM developers.

Now for the theme of this post. While searching for information about the Oberon family of operating systems, I discovered a video of a talk done by Niklaus Wirth at GTAC (Google Test Automation Conference), back in 2009.

I find it always very interesting to hear what he says, specially given his background, which tends to not follow whatever is considered mainstream in the industry.

He talks about the evolution of programming languages and testing along the years he has been involved in the computing world since his early days at the university.

Here is the video. Enjoy!

Based on my ORM experience I fully agree, ORMs seems to be quite nice way of making a database mapping quite fast, however the time won in designing the application is lost keeping track of database mappings or tracking down which queries need optimization and ending up with a frankenstein application of ORM mappings and SQL.

Usually if the project does not require any form of database ORM to be used, it is way better to make use of light weight mappings, or if constrained to a single database backend, to write the SQL directly.

You will be saved from annotation/xml mapping verbosity by doing so, while being able to achieve high database performance.

This presentation goes around how the environment and the programming language should mingle and provide an interactive way to develop applications. In a way much more powerful than the usual REPL environments, or even what the typical Smalltalk and Lisp environments do offer.

Khan Academy has a series of tutorials using JavaScript that apply the principles described on the talk.

This talk also inspired another developer to create a dynamic environment for Clojure development entitled Light Table.

The Frogatto and Friends game also has adopted some of these ideas into their game editor.

A Mozilla developer also created a Firefox plugin to explore JavaScript development following the same principles, a video is available, showing how everything works.

Althought the concepts shown at the talk are more relevant for doing UI related programming, it is an interesting concept that is surely worth one hour of time to go through the presentation.

I know it is a bit outdated, but it is still worth watching if you care about compiler development.

There is no JIT on the devices, the applications downloaded from the Windows Store are already compiled for the specific device.

Still it isn't 100% like C++ applications, because .NET only uses dynamic linking and Microsoft wants the applications to keep working after security or operating system updates are done to the device.

So they went with a solution which keeps symbolic locations for the memory addresses while everything else is plain assembly code. The references are replaced by real memory locations when the application gets installed, by using an on device linker.

This executable format is known as MDIL, Machine Dependent Intermediate Language. The compilation from MSIL into MDIL occurs on the Windows Store servers with an optimizing compiler.

• Deep Dive into the Kernel of .NET on Windows Phone 8
• Inside Compiler in the Cloud and MDIL

Now the question is when will Microsoft replace NGEN by MDIL for desktop applications. So far they don't confirm nor deny it.

• explicit conversion operators
• initializers lists (STL support will be updated in the CTP following this one)
• Raw string literals
• delegating constructors
• variadic templates (with perfect forwarding!)
• default template arguments

Additionally it was announced the ammount of work Microsoft, Google, Intel, ARM and many other companies are putting into the C++ standard.

A new web site for the C++ community is now available. The web site is backed from a new C++ foundation, which is a mix of ISO/ANSI members, C++ known individuals and companies with vested interest into the language.

An overview of the ISO ongoing work was also announced, the biggest one being the new target date of having a standard update in 2014, before the schedule update of 2017.

C++ is becoming a much more safer language for systems programming than C, as long as developers use modern C++ features.

As a supporter of strong type languages for systems programming, it is rewarding to see C++ improving, even with better languages trying to get its place.

It is a nice time to use languages with native code generation compilers.

This is really the best way to bring wonderfull experiences to the customers, by exploring the native features each platform makes available to developers.

To reinforced this, Common Lisp has made to the list of style guides Google keeps for all languages that are accepted for internal projects.

So without further ado, here is the Google Common Lisp Style Guide.

As two areas in computing that I like a lot are graphics programming and functional programming, it was very warming to have discovered a tutorial in YouTube that brings both of them together, by showing on how to implement a ray tracer in Lisp.

• Part 1.0.0
• Part 2.1.0
• Part 2.1.1
• Part 2.1.2

Slides are also available at the author's web site.

Enjoy.

It is quite nice that after decades of being imprisoned inside academia, functional programming is becoming just another paradigm that most languages are starting to make available to common programmers.

Carrying on the functional programming subject, there is a nice presentation in the Nordic Developers Conferece 2012 about functional programming with F#, as well as how to apply the same concepts in C# 4.0.

Quite handy, specially for those .NET developers that are only able to use C# at work.

A 1h30 session are length about real world usages of F# and Haskell.

This is a set of three talks done at Microsoft Research, showing how functional programming languages are slowly getting into the industry.

If you are a Mac OS X or iOS developer, there are lots of good stuff to watch there.

I'm still going through the presentations, but one that I can already advise is Modern Objective-C. Apple is really spending some effort to make the language a bit more modern, bit by bit.

This is specially important if you care about native code development.

Even if you are not an Apple developer you can still enjoy the videos after doing the free registration as Apple developer.

The videos are now available. Enjoy.

After considering the deployment scenarios and how users are supposed to use it, the decision which technologies to use ended up being C++ and Qt. As they are currently the best solution to develop native based applications for multiple operating systems.

It really feels refreshing having to code in C++, compared with my daily job of JVM and .NET languages. Sure the application takes a few more seconds to compile, but it is really worth it as seen by the application speed when using it.

Coupled with Qt, C++ feels like a language with batteries, as quite a lot of funtionality is made available out of the box, without having to search the Internet for libraries. Plus it also offers quite a few helper classes that minimize the need of explicit memory management.

Qt Creator IDE is a pleasure to use when compared to Java based IDEs, everything just works in less than one second, while keeping a nice IDE like experience.

On the Visual Studio Blog they have now stated that a version targeting the desktop will be made available as well.

Nice to see Microsoft being reasonable and accepting that they can't push Metro down our throat in the current state. Developers have to be able to decide on our own, which environments we want to target. Now if they just fixed the all caps menus.

More information available on the Going Native show.

If you are doing Windows only development with C++, this can be a nice addition to your toolchest.

The C++Now! 2012, former BoostCon, slides are now available. Video presentations will follow. If you can read German, there is a nice overview of the conference at heise.

Microsoft has also made available the videos from the Developing Windows 8 Metro style apps with C++ conference. Regardless of your position on Microsoft's latest moves in regard to Metro, C11, C++/CX and Express editions, this videos are quite interesting to watch, and Metro is here to stay no matter what. So the best way is to improve a bit our knowledge about it.

Facebook has released a new C++ library named Folly. Just have a look at it as it is full of nice stuff.

If you ever heard of Monads and still fight to grasp how they really work, this presentation is well worth one hour of your time.

She blends the presentation with the Alice in Wonderland story, make it entertaining while learning.

Nice to know that Lisp is still having some visibility, maybe Clojure also helps a bit.

Good luck, in case you apply for the job.

I have started to realize, that while some of the mainstream languages provide quite nice abstractions and productivity, they are tainted with lack of freedom.

Languages that are mainly brought to market by big companies, enjoy the benefit to quickly gather market share, have a big ecosystem around them, and have a better rate of supporting new features.

But hidden in a dark corner of all this cosy ecosystems, lies a trap. All business decisions become hostage of the whims from the company selling the language.

I have seen this happen too many times. Company X introduces a new programming language, eventually it gets adopted in the industry, later this company drops support for the programming language. All the companies that invested on the language are now stuck with a legacy language, where they have to invest a lot to find developers with the desired skill set, or to migrate their product to a newer programming language.

So what seems to save development costs, and delivery time to the market, because language X is so great. Ends up costing a lot more when the owning company decides otherwise.

Both options are costly. If a standard programming language had been used, the possibilities of having longer support would be greater, because thanks to the laws of the market several companies would be offering development environments for such languages.

The best way to assure business independence from such scenarios, is to rely in programming languages with available ISO/ANSI standards, or open source ones. This way there is more confidence that the language will subsyst much longer than the proprietary ones, and the possibility of litigation regarding existing implementations will be minimal.

Apparently they were disappointed with Go's GC performance and decided to move then to C instead.

This is a typical example of hackers having a say on company business, instead of thinking what makes business sense.

Go's GC will certanly get better, lets not forget that the language is only 2 years old, with version 1 released last week. And there are plenty of nice languages with runtimes making use of industrial strenght GC. Any of these languages would smoke Ruby's performance.

So the company decides to invest time and money recoding the said Ruby software two times. First to Go, then trying to understand what was going wrong with the new implementation, to finally recode it once again in C.

All this would have been spared had they decide to use a more mature language.

Don't take this blog entry as something against Go, as I think that the current GC problems will eventually be fixed, I just think it is an error to bet the company business in it for the time being and developers should use tools based on technical merit, not on what they like to use.

In business you don't get many second chances.

If you want to know more about WebGL, don't forget to visit the Learning WebGL blog.

Maybe in some years, another language will take its place. But like C, it will stay around for many decades still.

So the best way is to enjoy the videos and see some goodies from C++11:

• C++: A Language for Modern Times
• VC11 Auto-Vectorizer

I would also like to wish an happy Easter for those of you celebrating it.

It felt quite refreshing actually, since it has been a while I have done the type of low level memory management required by the exercise.

The article together with a possible solution is available on the Compilers tutorials area.

You can watch the GDC 2011 videos about it here:

• Part 1
• Part 2
• Part 3

I just did not like the comments about Java's GC in the third part, as it shows that the guy is not aware that the GC in most Java commercial JVMs are actually much more performant than what Mono or Microsoft have to offer. This is actually one area of improvement in the upcoming .NET 4.5.

It will be interesting to watch how well this will be picked up by the game developer community, as this is a place where native development is still king. Currently XNA and jMonkeyEngine are mostly used by indies or for the toolsets.

The platform has a few concepts that althought not new in the computing world, they are new in mainstream OS, like Intents for example. Where multiple applications cooperate by offering the capabilities to handle certain data types and in the end the application is actually a mashup of activities.

It was nice to get to know the WinRT framework that will be part of the Windows 8, and the possible long term replacement of the Win32 apis.

Another good side-effect from WinRT is that the Hungarian notation has gotten another death stab in the Windows platforms.

What is not so good about it, is that Microsoft on their usual way, prefered to taint native C++ with their own C++/CLI extensions instead of investing into a way of using standard C++ constructs with WinRT. It is a sad state of affairs, specially if you are old enough to remember how Borland was criticised for doing something similar with Borland C++ and later with C++ Builder.

Another consequence is that Visual C++ 11 will bring almost zero new features in what concerns the new C++11 standard, which has made many developers angry, as one can see in Visual C++ blog and channel9 comments.

The only good thing is that at least Microsoft has made C++ development again a bit more visible in their developer tools roadmap. They should however take care with the availability of competing C++ compilers that take C++ and C standards compliance seriously.

I am slowly starting to share the same opinion as the article portrays. For a few years I have been hoping that the JVM and .Net based languages would reach the performance level of pure native languages.

To a certain extent, the JIT offered by these languages are quite powefull, but still you can feel when using native applications or VM based ones.

Java's write once, run anywhere has never been quite true, due to bugs across JVM implementations that force developers to write workarounds, when changing the JVM is not a solution. .Net is mostly a Windows based VM even though Mono does provide support for part of it in another systems.

Lately there has been a trend to put VMs on top of VMs. So we have a JVM/.Net based application that runs inside a VM emulating hardware in some cloud, and I see this as a waste of resources.

We have multicore processors, with SIMD instructions and GPGPU, which are wasted by not being accessible to VM based languages. The access, when available, are usually via libraries and not provide the same access level that C and C++ allow.

So even myself, have started to play around with native languages for my home projects. There are a still a few around Delphi, Free Pascal, Ada if you like Algol style. C, C++, Objective-C, Go and D for C lovers and finally Haskell, Ocaml and Common Lisp for the funcional lovers.

Maybe having native compiler implementations for Java or .Net languages could be a nice addition to the developers toolset. For Java we have GJC, but it seems to be abandoned since 2009, even thought it is still part of gcc. For .Net, Microsoft has created Bartok, maybe they could eventually make it part of the .Net SDK.

Interesting times ahead.

Years later I made the interpreter available here in Progtools.

Due to my interest in F#, I decided that porting the Mini-ML source code F# would be a good exercise to learn about the differences between Caml/Ocaml and F#. So now the Mini-ML is also available as a F# based application.

The experience was nice. It was a bit hard to me to find out all the differences, but in the end I got the interpreter code without any dependence on Ocaml migration support libraries.

Enjoy!.

Not sure what to think about this. They should just have bet on one of the existing languages that target the JVM, Scala, Clojure or Groovy. From the presentation I got the feeling that they have a bit of "not invented here" syndrome.

As it is, I pretty much think that Ceylon is another language dead at birth. Specially since they have spent two years designing the language, and no compiler is still available.

Personally my time is better invested in C++/Go/D for native programming, Scala/Clojure for JVM or F# for .Net.

Just watched last evening the C++ Renaissance video in Channel 9.

Again it is nice to see that Microsoft has noticed that native development still plays a big role, and that many developers would like to see a bit more of love for C++ in Microsofts tooling.

Quite different from the lets go 100% .Net speech from the early .Net 1.0 days.

Nowadays both environments have their place in the IT world, it was just that C++ developers fellt negleted by Microsoft, now Microsoft is finally acknowleding that it needs to give more attention.

It is nice to see C++ back into the game. Or as some people would say "Back? But I never went away!".

The new system is written in C++ and runs on top of Linux. It replaced a .Net based solution that was giving lots of downtime problems to the London Stock Exchange.

They are not the first to take such decision, the German stock exchange is also running on top of Linux.

You can read about the complete story here..

For me this reveals a few issues. First of all, I imagine that maybe the .Net solution was not properly written, having seen quite a few monster architecture designs on my work life, that would be better with minimalist approaches.

Whatever the reason behind such failure, it gave lots of bad press to Microsoft, and to the Accenture team responsible for creating the said application. I bet the team might not even be working for Accenture, knowing jobs work in UK.

So as a Linux fan it was nice to see such turn of events.

Another thing I noticed was that they decided to use C++, instead of Java, which probably would make more sense if we look at the trends that see C++ as legacy. But as much as I like managed environments, they still cannot deliver the raw performance of C and C++, or any other native language for that matter.

After so many years of IT dating with managed enviroments, I imagine that people are now realizing that except for Web applications and low demanding response applications, native languages still win and will continue to do so.

In a way this a Deja-vu von the late seventies where P-Code enviroments, Lisp based machines and Smalltalk VMs where all the rage. Eventually they faded out, only to be taken up again by Java and later .Net.

I do program every day in Java and still like a lot the language, and lets be honest, it allows for very nice tools. But I am also having fun keeping my C++ skills up to date.

This is really a sad decision, Nokia is moving a way from a company that did quite some nice research work into one more OEM that just packs third party operating systems into their mobiles.

I have become a bit pragmatic over the years, and don't hold a bias against Microsoft as I did on my early open source days, but history has shown that most companies that did a partnership with them, got burned somehow.

I did work for Nokia, like any other company there were up and down moments, but it was a special company, and it is sad to see all the good people that still work there being put through this situation.

Having been a Nokia employee and known how the company works, makes the think that Symbian and MeeGo are now dead. Sure the message that they are trying to give to the developers is not to abandon the platforms and belive in Nokia.

But who can still believe in them? Maemo was going to be replaced by MeeGo, while GTK based framework became legacy and Qt was the future. Similary the Symbian developers were told how easy they could bring their software to the platform thanks to Open C/C++ and Qt. Later on, the strategy changed in a way that everyone was told to develop with Qt, this way both MeeGo and Symbian platforms could be targeted, but there would still be place for Java, Flash and Python.

Now a few months later, Nokia throws all these promisses out the window, and asks the developer community to belive in them, that 150 milion Symbian headsets are still planned to be sold and the platform will still be somehow around.

Problem is, I bet most hobby developers are just going to go away. The desilusion with out things turned out is just too big. And I fear that in a few years Nokia will just be known as Microsoft Mobiles, and what we are seeing today will be a use case in many management courses.

The only winner in this case will be Microsoft, they get Nokia to ship Windows Phone 7 based mobiles and thanks to their market size, finally manage to get a visible mobile platform, which many developers decided to ignore until this deal took place.

My thoughts are with the Nokia employees that gave so much for the internal development and will now be severely affected with this decision.

Some of the tutorials already make use of C++0x features, showing how modern proper C++ can be really made to look like.

Just go to MSDN page to have a look on the tutorials.

A little warning, the videos make use of Silverlight, which might be a problem if you don't like this sort of browser plugins, but the sessions contents are really worth installing it.

Enjoy the sessions.

One of the more interessing features is the ability now to fully develop in native code, plus the possibility to use STL with C++.

I am looking forward for a possible 2.3 upgrade, in case HTC makes it available.

What I like about the new design is that it makes the information more attractive. It should not matter for a programming language, but sometimes it does. For some users this is the type of small change that keeps them reading the available information on the web site or jump somewhere else.

I really enjoy the increase in visibility that funcional programming in now starting to have in the industry and having Haskell to be amog the chosen ones is really great.

One of the best videos to watch is the one from Jim Webber about doing 1 billion transactions per month in Java + HTTP.

One of the best parts of the talk is how Jim critics the SOA enterprise architectures that only lead to complexity and layers and layers of nonsense.

This is actually my opinion on SOA, for me it is a nice way of selling consulting services. There are lots of ways of doing similar architectures, without the Gigabyte stack of software required to do SOA.

I really think it is important what Microsoft is doing by briging the functional progamming to the mainstream. Thanks to Microsoft, we have now some people in the enterprise using a functional programming language, and lets not forget that some of the main Haskell researchers do work at Microsoft research.

If you like to learn more about functional programming and have to develop applications in .Net, maybe now is the time to have a look at F#.

Since until now Apple always developed their own JVM, which they have licensed from Sun, it is now an open question what will Java developers on the Mac platform do.

Will they rely on a custom build of the OpenJDK, or will Oracle step in and also provide a JDK for MacOS X like they do for other platforms?

Now I am really happy that I haven't bought a Mac so far. This news coupled with the Apples idea of having an App Store for MacOS X, only shows how the computing world can become if Apple was in charge.

Now even Microsoft is looking a very nice guy.

For more information about the news just check Slashdot or InfoQ.

So it is now it is clear to me, that most likely I won't ever get a Mac.

Sure it is a complex language, which requires some years to get the C++ Jedi Master level, but it also allows a level of multi-paradigm programming flexibility and performance, that few languages offer.

So with this in mind, there are a few ways for you to refresh your C++ knowledge. The first one is the video that is now available from the Bjarne Stroustrups's roadshow.

The othe information is the set of video tutorials created by Stephan T. Lavavej from the Microsoft Visual C++ team. They provide a nice overview over the STL capabilities, and you can find them here.

If you feel like playing around with the upcoming features of C++0x, you can get yourself a copy of GNU GNU gcc 4.5.0 or the Microsoft Visual Studio 2010 Express.

The presentation is available here and is very amusing to watch.

Even though I lean towards Python in the dynamic language's world, I would like that Ruby also stays around. :)

On a positive note, my HTC Desire just arrived and I am now exploring its capabilities, stay tuned for more information.

It ships with the Android 2.1 version, but I know that it can be upgraded to the 2.2 version, which I will surely do.

Then it will be the time to start exploring the device capabilities and toying with the idea of developing some applications.

For a Linux fan like myself, the big plus will be the ability to carry Linux on my pocket as well. Who would say that the small Unix clone from the early 90's would be in the heart of so many mobile phones?

I was really hoping that now with Qt, I could finally have some fun developing for Symbian mobiles.

Boy was I wrong! While trying to install the Qt libraries into the mobile, I get a simple Error -14 message. Very user friendly!

I even tried to ask the forum, but none of the advices did help.

I am now left with the possibility of going through the trouble of installing OpenC, Qt manually and hope it works.

But then again, it might not be worth it, because only applications for the N97 Mini and the X6 are accepted in the Ovi Store, as Nokia says on their site. They say another devices are going to be supported, but if I remember what they did to N-Gage users, the support will never come.

So I'm done with Symbian. Even with the recent Oracle/Google issue going on, my next mobile is going to be most likely an Android one.

When Sun did it to Microsoft a few years ago, it made sense. Microsoft was developing their own non standard Java implementation, while extending it to be Windows only, thus breaking the write once, run anywhere marketing campaign.

So Sun's move did make sense as a way to keep the language and runtime compatible across implementations.

When Google released Dalvik, this same discussion came back again, but somehow Sun seemed to be happy with it. Google was maintaining Java the language, while providing another runtime environment. Plus they were very carefull not to refer to it as a Java implementation.

But apparently Sun was not that happy about it, and their financial situation was the only thing preventing them to be more active against Google.

New reports about this case, seem to imply that this possibility was discussed during Sun's sale.

The problem is that Google is not Microsoft. On those days the programming community was on Sun's side, because Microsoft was seen as the bad guy. On the other hand Google is still a hero on the eyes of the majority of the open source community and Oracle is not Sun.

Regardless how this case ends up to be, most likely Oracle has just killed Java.

Sure there are millions of lines of code being written in Java every day. It is also my main programming language, at least for the time being. But Java was already loosing its appeal as programming language, now thanks to Oracle, many developers will desdain the language for political reasons as well.

On a side note, it seems Oracle has killed OpenSolaris development as well.

It only goes to show how bad it was for Sun products to be bought by Oracle. On the long run they will alianate everyone that still had a positive remark about Java or Solaris.

The language is a nice evolution from C, and might be able to replace it as the next language to use for systems programming. It provides some nice concepts to help developing multicore applications, like message channels and go routines. It is also a type safe language, with garbage collection, type inference and interface programming.

But I am not sure that the language is going to get widespread use if their developers don't provide features that we have got used to have available in other languages.

I speak namely of enumerations, generics, dynamic linking, dynamic loading and exceptions.

Most of the Go users seem to be against having these features available in Go, with the argument that they would render the language too complex.

I think that without supporting what every mainstream language already provides, Go will be just another language. Unless due to Google's influence it happens to get a broad userbase.

Me personally I will follow every now and then how the language evolves, but I think my time is better spent with F#/Scala/Haskell.

Now it has come to the Android world, allowing several people to acquire a bit of task what programming is all about.

You can read more about it at the official web site.

Another piece of information that is also quite nice to know, is that they make use of Scheme environment for the JVM, as their solution to generate and compile the visual code.

But has you can see, the proposed syntax is really bad. I cannot understand how come they have choosen such an awfull way to declare closures. Any other language with such a feature has better syntax than what is being proposed for Java.

As you can see from another InfoQ article, most people are not that happy with the current decision.

I used to be a Java fan, and I use it everyday on my work, but with the way that generics were introduced and now this awfull syntax for dealing with closures in the language, they (Sun/Oracle) are killing the language.

I just hope that they get some common sense before the final syntax gets decided.

Now available at Intel's Blog.

Haskell programmers around the world, rejoice! Functional programming is slowly becoming mainstream.

Have fun updating your OpenGL skills.

Now they have done me a favour. I will never buy a PS3, after their decision to remove support for Linux from the older PS3 version, as reported by Slashdot and OSNews web sites.

Even if you don't like Linux, this is an attack to consumers. When you buy a product, you buy it for a specific set of funcionalities. How can a company dare to come back, after they got your money, and say that will remove one feature from something that is suppoesed to be yours?!

I for one, will stay away from Sony game related products from now on. Now getting a XBox 360 is really getting appeling, regardless of how you see Microsoft, they care much more about consumers.

I am using my first 2010's post to say a big thank you to NVidia. I think I own them this much because I am always complaining about their love/hate relationship with OpenGL.

On one side, they are one of the big players in the Khronos Group pushing for the new versions of the OpenGL standard, but on the other hand many of their freely available tools don't provide proper OpenGL/GLSL/OpenCL support. Which always leaves indie developers and hobbists like me to wonder how commited they really are.

But yesterday I got something nice from NVidia. Thanks to their new NVidia Verde program it is now possible to update laptop drivers, instead of being forced to fight with the laptop manufactuer to provide them.

The first time I tried to update my drivers, the laptop was still not supported by the program and I gave my feedback, and I guess many other users.

So yesterday it was a pleasant surprise not only to find that it was possible to update to a newer version, but that now I can also properly play around with OpenGL 3.2 and OpenCL 1.0 on my laptop.

So many thanks to NVidia, and I hope that they continue they good work supporting OpenGL and developers on the move like myself.

This was my second time attending the conference, the first being back in 2003 at Earls Court in London. I must say that comparing both conferences, the one in London was better organized in terms of Lectures. This time I attended a few ones lacking content and sounding more to marketing sessions than anything else.

Still I did manage to learn a few things along the conference and even talked to a few people.

The Keynote sessions were all quite interesting. Today I also managed to see live one of the best game designers out there, Peter Molyneux.

A few trends that I observed during the conference.

C# seems to have settled as the election language for tool development. OpenGL is pretty much dead in what concerns the Windows platform. Most Studios will only care about OpenGL on the platforms where it is the oficial graphics API, like the iPhone or the PS3. Which is kind of sad, but understandable if we take into consideration all the issues around game development.

Since many attendees were Americans, there were lots of iPhones and Blackberries going around. On the mobile development front iPhone is getting all the attention.

The new Crytech engine is just great. I saw two live demos of it and both were quite amazing.

Finally, there were quite a few attendees carrying Macs around, but a few of them were actually running Windows!

Oh! I am eagerly waiting for Larrabee to be fully disclosed, but we still need to await around one year.

I really have to congratulate them. Besides all the negative press that they got around the OpenGL 3.0 release, they have been doing a good job after that and the industry has been a good supporter. Assuming it keeps going like this, we may still have a future for OpenGL.

Together with the announcement, they have also made available a nice reference card.

On Windows, DirectX might have woon the number one position as the main API, but OpenGL keeps on leaving as the only portable 3D API that there is currently available. I have a love/hate relationship with Microsoft products, and having OpenGL around is also a nice way to force improvements to products coming out of Redmond.

Since we are still talking about OpenGL related stuff, just have a look at recent OpenCL video published by AMD.

The best way to get yourself informed about it, is to read the Bjarne's article at Doctor Dobbs Journal.

It is pity that a feature, which could improve C++ error messages got dropped like that. I do however understand the reasoning behind, specially due to the fact of it being a commitee feature without real life experience. The exception specifications and external templates features already showned us that is not a good idea.

On top of that, it is now visible that C++0x will become C++1x, since there is still too much work to finish, before the first compilers can be fully compliant with the standard.

Would this be a good signal for a new systems language to appear? Who knows, but for the time being C++ has still its place on the industry.

While you might not agree with the article, it is true that many supposed developers are only doing configuration file programming and lack many skills you would expect from a developer.

This is specially true with people working in the industry without a proper CS background, and because of that complain that somethings are too complex. Although it is true that many programming tasks could be simplified, people should know how to use their tools of trade, and more important, why they work as they do.

Nokia seems to be promoting the use of language runtimes, meaning Java, Flex, Python and Widgets as a way to easily write applications. And for C++ developers the rote seems to be related to QT for mobiles.

For me this clearly shows that Nokia might be receiving lots of negative feedback when comparing the pain of using Symbian C++ with the development process to the iPhone, Android or Linux based mobiles.

So I for one applaud their effort to ease our lives as developers, just don't know if they will come on time to fight the advance of the other platforms, specially the Apple based ones.

Lately I have been watching the videos from the latest Lang.NET Symposium. Most of them are quite interesting.

Regardless of what you might think about Microsoft, I see as a good think that they push people to research managed languages. And the conference even had quite a few speakers doing JVM related work.

I just did not like the talk about dropping C/C++ in favour of C# for doing Linux development. I think that the speaker really does not understand what is behind Linux. If Microsoft makes the full .Net stack available as a ECMA standard, without patents, then we might have some reason, but that is all.

Remember that you will need Silverlight to watch the videos.

NVidia has already made 3.1 compliant drivers available

If Khronos keeps with the current rhythm, the OpenGL fans don't need to be scared of OpenGL fading away. Lets hope that is the case, the world really needs a nice portable 3D API.

It is improving quite well and I'll be able to release this updated version in the next few days. jQuery really rocks.

On the afternoon I am planning to attend talks about GNUStep, XWindows and Graphics programming in Java.

I will later post some informations about how those talks went.

Update: Here goes a small update, now that the first day has ended. I ended up attending the following conferences:

• New theme engine in GNUStep
• Changes introduced in XRanR
• What has happened on Nouveau's development
• Accelerating embeded Java with OpenGL ES
• Increasing Java 2D performance with XRender

From all talks, what I enjoyed most was the X development related ones. The other ones were a bit dry. But one thing I already learned, X talks have a lot of interested people, one really needs to arrive early, otherwise there one stays outside.

I also enjoyed the projects that were showing something on their booths. More on that when I return to Dusseldorf.

In case you don't own the Microsoft Visual Studio, there is the possibility to install just the running part of the IDE. The F# installer will then use it as the normal Visual Studio.

You should do the following steps:

• Download the Microsoft Visual Studio Shell, integrated mode
• Run the installation.
• This will only unpack the real installation, so you need to execute it again.
• Now install F#
• You will have now a Visual Studio installation, with support for F#

Happy coding with F#. :)

Vista does not support it that well, but with Windows 7, even though it is a Beta, thus slower and heavier than a release build, it is lighter than XP.

The only negative thing so far, seems to be that the fan is working more than with XP, but that might be because of Aero using DirectX, making the graphics card work more, or some driver problem.

Either way it is the first public beta, so we cannot ask for perfection.

From this first experience, I am looking forward for the final release and will continue to play with it.

I guess I am being atracted to the dark side of the force. :)

It was made by Rogerio Perdiz, with help of Blender, Gimp and Inkscape.

It is very interesting to see how far he managed to go with these tools, a very good example that others can follow to try to get a footstep into the industry.

Jonathan Blow is unfortunely right about the state of affairs, and I guess it is the main reason why many game developers stay away from the platform. Another problem is the type of answer one does get sometimes. Even Jonathan complains about it. Nowadays there are lots of teenagers full of anger against anything besides Linux and don't have any idea what real developer tools look like.

Anyway we are at the begining of a new year and we can hope that the situation will improve. Happy 2009!

So I have settled on Xubuntu as Linux distribution, because most of the provided software is correctly translated into European Portuguese, and it uses XFCE as desktop environment. It seemed a good choice, but it was not. I am not able to configure X with more than 800x600 resolution, and network still does not work.

A friend of mine is having similar problems with the latest Ubuntu.

I still might try with PuppyLinux or with Slackware, but I am not willing to spend that much time with it.

I am disappointed, so Java will be one of the few mainstream languages not supporting closures. Maybe we are able to get them on Java 8.

Luckly Sun is now backing another languages on the JVM, so at least we are able to be productive with Scala, Groovy, Jython and JRuby on the JVM.

I really don't understand these sort of programmers that fear closures, for me they seem like people that only understand Java, and are average programmers. Based on my experience, any programmer with a proper CS curriculum will have full understanding of closures and their benefits.

Maybe the problem is that many universities are now producing dumb programmers?

You can get all the information on the Khronos web site

Lets hope that the graphic card manufacturers get OpenCL aware drivers, released quite soon.

It was not easy task. I had to play around with a few distributions, but in the end I managed to find one that almost worked with everything.

I started with the latest Fedora, Fedora Core 10, which was a very big disappointment. The distribution seems to have a few new interesting features. However it never managed to recognized my network. Something that all other distributions never failed to do. Besides it has some strange behaviours where the CPU has a 100% load most of the time!.

At first I thought it might be a problem with the KDE version, so I ended up resinstalling the GNOME one, just to experience the same results.

Then I was using the Mandriva ONE 2006 live CD, just to help me download the new 2009 ISO. Which did not work because any of the available browsers were able to keep up with the download, thus making it an impossible task.

Luckly I also have a Knoppix CD, so with it I was able to download the Mandriva ONE 2009 ISO, and burn it.

The Mandriva distribution is really nice, and to my liking is still one of the best desktop distributions around. And amazingly it is the first time, all my laptop special buttons worked out of the box.

Still I am writting this post from my XP installation, because even though I was able to run Mandriva almost without problems, there were still a few that prevented it from being my main OS.

My laptop fans have thermostat and only work when it is really hot, or the CPU is having some hard work. With all tried distributions, even Mandriva, my fans kept working at full speed, and lm_sensors does not recognize my motherboard.

Using libdvdcss I was able to watch DVDs, but without sound, which does not help that much.

Finally, I do use Windows Media Player a lot, because as someone living abroad, I really enjoy the ability to see some TV or radio shows, on the web. The main problem is that currently many of these senders are using WMP 11 codecs, which are not properly supported by Win32Codecs package. The other solution would be to use the Fluendo codecs, but I still need to think if I really want to pay for something that I get for free on Windows and MacOSX.

So, until I can sort out these problems, I am back to XP.

They have put up a nice show, and all the bands acting before them, were also very good to hear. Only Stereo MCs seemed to be a bit out of place for the Orishas type of public. Still they have also given a good show.

As you might recall from previous postings, or by reading around the Web, Sony does not allow access to the RSX chip, thus preventing Linux to make use of accelerated 3D graphics.

There are a few people from the Homebrew community trying to get around the Hypervisor, and there is also a Mesa driver that does software rendering using the Cell processors.

Both solutions help alleviate the problem, but that don't make it go away.

But lately I have started wondering if the community isn't the one to blame for such state of affairs. If you go to the former Playstation 2 Linux Web site, you will see most people are worried to use the PS2 as a router, mini-server, or a plain desktop.

What won't you see, is too many discussions regarding game development on the PS2 Linux.

So was this deviation from the PS2 main goal, that made Sony think that it isn't worth to give Linux access to the RSX chip?

Then, I met a friend by chance on the tram, and thanks to her, I've found out that a mutual friend would be in town. Someone that I haven't met since 2006 and is now in Germany for some trainings.

So in the end, we ended up meeting, and talked about what each of us has been doing on these last two years and life in general.

It was really great. I wish all surprises in life could be that good.

However it is still not this time that I will get one. My 17 inches laptop is still in great shape and it was 1000 euros cheaper than the 17 inches MacBook Pro.

The only thing the Apple laptop has going for it, is a dual core processor. Even my graphics card, a GeForce 6800, has more internal memory.

So if what you care about is graphics programming, better stay with a PC, at least until Apple starts to offer more options.

Oh! And did I mention that they do not support Firewire anymore?

What can I say? They continue as great as always! I wish that they still have a long life ahead of them as band.

If you happen to live in Aveiro, I can only advise you to keep watching for the next ones.

I think that the value our industry gives to certifications is a bit overheighted, but they play a major role nontheless, so I decided that it was time to get certified.

Now I have free time again to dedicate to jME :)

His is kind of right. What many people on the Linux community don't understand is that supporting portable APIs is not enough. On commercial titles there is a whole set of support to expect that Linux just don't have.

Windows, with all its problems, is still more manageable than Linux in what concerns managing to run a game sucessfuly. Many people moved from PCs to consoles because you just need to plug a disc to play the game, without further configuration problems.

I can't image tech support telling normal users to change configuration scripts under /etc to make their game able to run on a given distribution. Sadly I have to agree with John.

As a result, the OpenGL forums exploded with complaints that people would drop support for OpenGL and that the CAD companies are to blame for what happened.

Now the sentiments seem to have settled down a bit, and the SIGGRAPHs BOF also helped to calm down the people. Lets see what the future holds for OpenGL.

Me personally, as a Linux fan, I would like to see that OpenGL as a relevant multiplatform API. But I see the danger of OpenGL going to join PHIGS, Glide, among others, on the 3D API heaven, if Khronos doesn't fulfill their promisse regarding the 6 months delivery for OpenGL 3.1.

I did meet a few nice people and enjoyed most of it. That was the good part of the whole day.

The bad part was having to endure the rain that was falling every now and then, spoiling a bit the fun that we would otherwise have if it was a shinny day.

I decided to leave the ugly part to the end. The ugly part was having to go thru four police control points that were simply not prepared for the amount of people that came to the Love Parade. There were people faiting, having bruises and it was very unpleasant to move between check points. Had the police left the people to walk on their on to the train station, everything would have gone a way lot better. At least that is my gut feeling.

The project sure was, and is, alive! The thing was, that time is a limited quantity and priority has given to some other tasks.

But now the site has goten a clean face that really shows the framework is alive and waiting for you to try it out.

Picking on XNA as well, I think that XNA and Java Monkey Engine, are two good examples for frameworks, which can be used to produce cool games. Not all games need to be the next Crysis.

At the same time, the Creators Club Online has been updated for the online community, the so called You Tube for Games.

Independent of my position regarding what Microsoft does and their business practices, I find XNA a very good tool. It allows many students and bedroom coders to do something that might give them an entry point into the Game Industry. Sure they can still do it with C, C++, Java and whatever toolkit they like. But XNA provides an infrastructure that helps them into the right direction and for the good or bad, some important companies are starting to give an important look to XNA.

Me personally would like that the Java Monkey Engine would be something similar to XNA. But while Sun doesn't have a clear picture what to do with Java3D, JOGL and other similar graphics projects, Microsoft does have a clear goal. When they realize what they should do, most game developers will be happily developing with XNA.

I know that at least I will play at little with it.

Anyway back to the book. The book was written by a German that lived for some time in Portugal and it is really cool! It contains a few sterotypes and some exageration sometimes, but it is overall funny, and I as a Portuguese really had a laugh while reading it. So if you know German, I advise you to read it, specially if you are Portuguese.

I also enjoyed the presentations that were done. I'm already thinking about attending the next one. :)

You might think that this was a lot of travelling around, but actually when one lives on the middle of Europe it is kind of easy to travell around like that.

Vienna was really nice. My last time there was back in 2003, and now I had a bit more time to get to know the city. We really found lots of nice places and the Austrian gastronomy is also very tasty. :)

Amersfoot was then the opportunity to meet some of my friends on a new stage of their life. The city seems very welcoming. And we also took the oportunity to spend a day in Amesterdam because both cities are quite close to each other. And in Netherlands I also got the opportunity to taste new gastronomy trends. Also very nice. :)

Now it is time to get back to work.

This is work in progress, currently only the blog page has the new layout. I will update the rest during this week or on the next weekend.

And the best of all is that they are all in PDF format. :)

Anyway, if you can overcome the prejudice of having to have Silverlight installed, the talks are quite interesting.

In case you don't know them, the Phoneheads are a Drum and Bass band from Dusseldorf. It was very enjoyable to see how they were able to mix their music with classic music.

So even if Microsoft technologies aren't your cup of tea, Channel 9 might be worth a look.

The Portuguese game studio is called Biodroid, and they seem to have on their plans a game for the Wii.

As a side note, Reuters will use Java for their Real Time Systems.

On a side note, I have found that the videos from the last Ruby conference are online, and even though I tend to lean more to the Python side, I've been watching the conference videos. There is pretty cool stuff to watch. Even if you don't intend to develop applications in Ruby, I advice you to take a look at the videos. You can always learn something new.

Now for the blog entry subject. If you are into software development, I have found out a very nice site with podcasts about software development. It is called the Software Engineering Radio.

After some experiments, like a tic-tac-toe game and some OpenGL/ES examples, I failed to find the platform as interessant as I was expecting. First of all, one has to program on a weird C++ dialect, full of concepts like "Two phase initialization", functions that can leave and lack of full ISO-C++ support. And STL is also missing.

The reasoning for many of the design decisions behind Symbian-C++ is due to the hardware constraints of the devices where SymbianOS used to run. However the latest handsets are more powefull that my first PCs (386->Pentium), so I don't see why I have to use a weaker version of C++ than I had to use on those days.

And at least on my handset, the J2ME performance is quite good. So I'm giving up on Symbian-C++ until it gets more programmer friendly or I get paid to endure its pains.

The language really looks quite nice, and I specially like the Smalltalk feel that one can see on the language itself. However I don't see myself making a huge investment into taking Ruby into use. And the main reason for it is that I have been using Python for quite some time now. Besides code blocks, I don't see many advantages of Ruby over Python.

Sure I might use it the future, if the need arises. But for the time being, Python serves my dynamic language programming requirements, specially due to the wider support it has.

For those of you that don't know iti, F# is a funcional language for .Net based on the ML familly of languages. I've always been a great fan of funcional programming, having had my first contact with Caml Light. One of the things that attracted me to Python was the functional programming possibilities that the language somehow offered at the time.

Python and Ruby offer many funcional based contructs and they somehow helped more people to become more aware of funcional programming. Haskell keeps on attracting users and since Pugs makes use of it, it gained a bit more of traction. Not to forget that one of the research institutes using the language it Microsoft Research itself.

Now having a big company like Microsoft backing a functional language in their official set of programming languages will only help the cause, regardless of one may think about the company itself.

I for one, am not a super fan of Microsoft, but I am glad that they are productizing F# and will for sure have a look at the language. Who knows maybe functional programming might be the next breakthrough in the industry, after OOP. :)

Since then I became well versed in the language and even had the oportunity to use it in HPC scenarios, during my stay at CERN.

But currently I spend most of my working time with managed languages (Java, Python, etc), and only code in C++ when need arises. I only use C++ for personal projects, or when it is the best tool for a given job. Otherwise I stay on the cosy world of higher level languages as C++. :)

But I try to keep me up to date with the C++ language revision, and some of the changes, like concepts, which appeal to me. However I am a bit sceptisc that the world will notice C++0x when it comes out.

We are in 2007 and as far as I know, there isn't a single C++ compiler that fully implements the Ansi C++ 98. Assuming that C++0x will be C++ 09, when will the first 100% compliant compiler appear? And how should we write portable code in the mean time?

This was always a plague in the C++ world, how to take advantage of new language features and yet keep the programs portable.

Currently C++ is the best language for doing systems programming, however the world moves on, and new solutions keep on appearing. There were other languages for systems programming before C++ and there will be surely other ones afterward.

In a world, where most IT projects moved away from C++ to Java, C# and even on a smaller scale to Objective-C, will there be any major project taking advantage of C++0x? In my area C++ is only being used when the other languages are not performant enough, or for legacy projects.

C++ will still be a long time with us, and many new applications are still being written on it, I just don't know if anyone will care for C++0x.

However if you care about it, have a look at Wikipedia's article, Gcc's support of the language and the ConceptGCC compiler.

When PS3 was announced, I as PS fan was already salivating for getting one. It was going to play blue-ray, have Cell processors and support Linux from day one, what more could a techie savy person wish for?

What do we have now? A console that when compared to its American or Asian counterparts is handicaped. And Sony continues to keep on hold the support for the graphics processor on the PS3 Linux.

It seems that Sony lost touch with their fans. The ones that made PS1 and PS2 famous and now have to depart somewhere else.

I'm still hoping that the situation will change, but I'm not waiting forever.

I was there showing the city and surroundings to a few german friends. They seemed to have enjoyed it. I did as well, after all it not all the time that we get to enjoy our city together with some foreign friends. I hope everyone returned safely back home and see you guys in some days.

Switching to another theme, if you haven't seen the Simpsons movie, please do so. And stay all the way until the end, the movie is hillarious and full of small surprises.

I also found out that the Portugese National TV now has a few live transmitions via Internet. Way to go RTP!! If at least the other TVs would follow you. We can only wish. :)

I know that last year I was considering other technologies besides PHP, and to be honest I don't like it that much. But it gets the job done and is easily portable for other servers if needed. But I would gladly play around with Ruby on Rails if the oportunity comes up. :)

Last week I went to the Chemical Brothers concert here in Dusseldorf. If you like them, and you happen to live nearby one of their tour places, then I advise you to go to their concert. Here it was quite cool.

But I've also got to know Spezializtz from G.B.Z. which seem to be very well known over here.

I think there is really good potencial for proper games on cell phones, but developers need to focus on the available controls and not do simple ports of known games. My disappoint has been growing everytime I try a new mobile version of known games from Amiga or SNES days, the mobiles just weren't made for them.

Maybe every game developer and publisher should take care that a cell phone keyboard is not the same thing as a PS2 controller.

I just add a new application for doing very simple image processing, creativily named ImageProcessor.

Now if they just could improve the C++ support as well.

This week I've finally removed Linux from my laptop. So why did I, a Linux fan, irradicated Linux from my own laptop?

The answer is quite simple, lack of support. My last attempts were based on Mandriva 2007 and Fedora Core 6. These distributions were the first ones that properly supported my screen resolution and sound card out of the box.

But they kept on hanging! Surely an X Windows/NVidia driver problem, as I have seen before. But these crashes always meant a cold reboot, the last one even made me reflash my BIOS. I still don't understand how a OS crash can be related to a corrupted flash BIOS but it happened.

And even if the Linux would be working ok, I would still need to configure the support to multimedia using the binary only win32codes, using binary drivers for my WiFi card, not be able to use my laptop remote, and I would still need Windows for gamming and Symbian development.

So I just lost my patience and my laptop is again a Windows only one. Please note that this doesn't mean I lost my faith on Linux. My work is mostly done in Linux, and I have other computers with Linux installed, but this laptop will not have Linux for the time being.

The sad fact about this is that we are now in 2006, 12 years after I started using Linux (slackware 2) and some problems are still the same.

And even though more manufacters support Linux, some of them just do it as a marketing thing. Just look for all those network adapters manufacters that use Linux on their rooters but don't provide support for the WiFi cards. Or Sony that supports Linux on PS3 but without graphics acceleration. And I could surely get more examples.

I should also praise Microsoft for them opening XBox 360 to game hobbyists. This time they seem to have an edge start to PS3. As an happy PS2 Linux owner I was expecting better support from Sony, but they seem to think otherwise. Most available reports so far seem to suggest that even the officially supported Yellow Dog Linux isn't able to use the graphics hardware. So what the use of running Linux on PS3 if it is just for looking cool?

The sound system and WiFi are still not working. I could tweak configuration files, but somehow along the years I lost the motivation to keep on doing it.

And my current usage of the laptop requires the use of Windows due to some Windows only software like the Symbian SDK. So my Linux distribution is only getting digital dust.

If Mandriva 2007 or Fedora Core 6 still do not support it, maybe it's time to regain that lost partition.

Paralel to that I'm also doing some Photo development workshop, let's see how it goes.

And to end this update, I'm now playing with Symbian OS in C++. It's kind of cool because it is a bit like old school coding. I'll put some results on my site when I have them ready. As usual my friends have priority over my hobby coding, so these projects tend to go a bit slow.

So see you next year Mera Luna!

So all the best to you Ines, and see you in Lisbon in a few weeks time.

Another reason was that it was very good to see how far Portugal managed to go. It's true we got defeated yesterday but we managed to come all the way to 4th place. Most of the other countries are already at home. :)

So thanks once more and see you around in some event. The pictures will be made available still this week for the persons with access to my gallery.

And during the Easter hollidays I had a visit from two good friends from my time in Geneva. We amused ourselfs touring around Dusseldorf and all its terraces.

This made me think a bit about friendship, and I decided to publish as a blog entry, something that everyone knows but is good to write it down. Friends is one of the best things you can get during life, just be sure you keep them!

And before someone starts wondering. The mappings are correctly defined. Only with this IDE, things keep on failing.

This really makes me miss the days when using a Tcl application server where this type of mapping would just take some minutes and work out of the box. Somewhat similar to the currently famous Ruby on Rails.

Stay tuned for the photos. I'll make them available as soon as I have some free time.

It seems that IBM uses Tcl as a scripting language for the Websphere server. This is quite cool, it's been a while since I've used the language for the last time. The language is quite cool and it brought me found memories from when I was working at Altitude Software.

As a final note, I should add that Spring seems to be arriving to Dusseldorf. Finally I can continue to do inline skating!

The Linux and Sun sections were also interesting to attend. NVidia's section took a few booths and was always croweded. As usual I took some pictures of the events.

And I've updated my C++ and Bison tutorial for a more recent version of g++.

And I will start by removing my contratulations to the SIC Portuguese Channel. Those guys only had their site open for connections outside Portugal for a few days. I've sent them a complaint email, joking a bit, I must confess. Got their reply saying that they can't transmit outside of the county. Feel free to read it if you understand portuguese.

Now the funny thing is. The RTP and TVI channels are able to transmit outside of the country, even if they charge for it. How come SIC can't do the same?!

Of course, my main reason is to be able to keep in touch with SIC Radical.

I've also added an entry to a new parser generator, Gardens Point

I've always had a love for good movies, you know, the type of movies that aren't made just to sell popcorns. So it's nice to see the cinema club getting the Oita cinema back into action. I do understand they also need to show some more comercial movies from time to time. But at least we have a group of people to thank for keeping the cinema running.

Now they just need your presence. So if you are in Aveiro, Portugal just pay a visit to Oita's cinema. You might get to see a good movie.

Even though the weather could have been better, I had lots of fun and discovered several cool bands, like Faun, Schandmaul, Leave's Eyes, among others.

If you apreciate Gothic Music then I would advise you to come by next year.

It was lots of monuments to see, mostly churches. Exhibitions, channels like Amesterdam, and a nice gastronomy. :)

If you have time, rent a bike, it's really the best way to go around the city.

I just don't know why they also had Casal Garcia on the list of Spanish wines when it is a Portuguese one. Oh well, at least it helps spread the knowledge about it. :)

My condolonces to everyone that lost a loved one in the London attack.

As you might have noticed from previous entries, I've started to put some pictures in the site. The new version will of the site will have some sort of gallery. :)

Now I just have to try to go thru the rest of my working day and prepare for another weekend! Have a nice weekend.

Will it be the foundation of the next version of this site? Probably not due to lack of availability where to run it, but let's see.

Last week it was Carnaval (or in german Karneval) and I took the opportunity to grab some photos of the parade. You can see them in my gallery. Enjoy.

It's been two years since I left Portugal and went to work for CERN in Switzerland and leaving in France. Funny situation but pretty common in the Geneva area.

Eventually I got a job at Nokia in the Dusseldorf R&D center. So here I am now in a new city, new country and starting to now German.

It is called tactics.

If you have anything to suggest in the port, please let me know.

A new game has been added, or should I say a new version of an old one ?

The Java Checkers game has been ported to .Net/C# and is now on the site. Have fun !

Feel free to take a look around. Please mail me if you have any suggestions to make