Introducing some samples for Vercel Functions with native languages

About a year ago I made the point that working with Node.js felt a bit like my old days of programming in Tcl with native libraries

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.

Some security related updates

In a couple of security related news, ReadWrite has a mention that the NSA has updated the set of memory-safe programming languages to the following ones:

• 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.

.NET 8 is now available

.NET 8 has finally arrived, with lots on goodies in the form of C# 12, F# 8, AOT improvements, and a surprise framework for cloud native development, .NET Aspire

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.

C++ security related news

Microsoft has recently published as very interesting guide on how to Build reliable and secure C++ programs, which everyone doing C++ development should spend some time reading.

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++.

C++/WinRT now in maintenance mode

Apparently all hopes from ever seeing C++/WinRT reach feature parity with its predecessor, C++/CX, are now gone. It has been formely declared to be in maintenance mode on its Github repository.

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.

Upcoming Windows security improvements

During last week's BlueHat IL security conference, there was a very interesting talk regarding ongoing improvements on Windows security.

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.

Going back to Web roots

For several reasons I have been busy doing some Web development with Node.js, which kind of reminded me of my roots how I started into Web development.

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.

Google's security blog post on Android

Google's security team just posted a blog post entitled Memory Safe Languages in Android 13, which main focus is how Android 13 is the first OS version where all new code was mostly written in safe languages.

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.

What's Old in Windows App SDK 1.2

The WinUI team just celebrated the release of the new Windows App SDK 1.2.

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

KataOS, Sparrow and RustyHermit added to safe systems article

I got around updating my Safe Systems article with a couple of newer systems that are making use of Rust programming language.

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.

A better strategy for safer code

While going through some online discussions today regarding how to write safe code I had a kind of epiphany on how to better spend my advocacy time.

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.

Tour of C++ book has a new revision

I just noticed that the 3rd revision of Tour of C++ has just become available.

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 :).

C++/WinRT still not ready to replace C++/CX

Almost two years ago I had a blog post entitled C++/WinRT not yet ready to replace C++/CX, about my disapointment regarding the lack of tooling in C++/WinRT, specially when compared with other C++ GUI frameworks.

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.

C++ modules example in UWP and C++/WinRT

Finally managed to make C++20 modules work as part of a C++/WinRT application, targeting UWP.

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

.NET 6 is looking quite interesting

It has been a while since my last .NET 6 post, and with the release date approaching, Microsoft has made quite a few interesting blog posts.

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.

.NET 6 is here!

This week Microsoft just made the first preview release of .NET 6 available.

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.

-fanalyzer, my favourite new switch on the upcoming GCC 11

GCC developers are improving the capabilities of its C static analysis tools, as means to improve code quality.

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.

Polyglot programming love from Microsoft

Microsoft just released a bindings generation tool for the Win32 API.

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.

Google's Project Zero finds yet another buffer overrun exploit

Google´s Project Zero has a very lengthy and thorough analysis of an iOS exploit caused by a kernel memory corruption, usually known as buffer overrun, sadly yet another proof that we really need to move on to safer systems programming languages, as every mitigation effort is only delaying the inevitable.

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.

.NET 5 is here!

Finally .NET 5 is available as a stable release, and it brings lots of interesting goodies, regarding performance, C# 9, F# 5 language features and tooling for cloud computing, micro services, GUI applications and machine learning across several platforms.

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.

C, Go, UWP and on being wrong

Sometimes there are paths one follows as the way things should be, until being forced to be corrected. The themes today somehow fell under that umbrella.

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.

Azure Sphere after all not so secure

Late 2019 Microsoft has started a bounty program to find security issues in Azure Sphere, apply named Azure Sphere Security Research Challenge

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.

Adventures with Visual C++'s lifetime checker

Now that I have ported my old A* Demo application into C++/WinRT, using Visual Studio 2019, I decided why not have a look at the Visual C++'s lifetime checker.

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.

A*Demo ported to C++/WinRT

Despite my rant regarding C++/WinRT, I ended up porting an old mini-project, from C++/CX into C++/WinRT, as means to get an appreciation of the C++/WinRT current tooling support.

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.

C# Source Generators, D lifetime prototype, Rust on Azure and WinRT support

Today a couple of interesting news around a few of my favourite languages came together.

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.

C++/WinRT not yet ready to replace C++/CX

Given that Microsoft has been talking for quite some time that C++/WinRT is the replacement for C++/CX, I have decided to give it a go.

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.

Awesome Modern C++

I just became aware of a nice collection of Modern C++ resources, Awesome Modern C++, which provides a very nice list of best practices, books, talks, tooling and libraries to take advantage of C++ features added to the language post C++11.

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.

TamaGo - bare metal Go framework for ARM SoCs

The 2019 edition of 36c3 conference of Computer Chaos Club, had a very interesting talk on TamaGo, yet another attempt to run Go directly on embedded hardware, as secure alternative to C.

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.

Lilith: x86-64 OS written in Crystal

As early Christmas gift to the security minded system developers, I just saw the annoucement of Lilith, an OS written in a patched version of Cristal, withouth giving up on its automatic memory management capabilities.

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.

Updated Oberon and safe systems overview

I got contacted by someone from the Active Oberon community, regarding an updated language report. As such, I got to update the existing Oberon overview with links to the language report, new forum and Telegram community channel.

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.

Google is adopting Arm’s Memory Tagging Extensions in Android

Google has announced on their security blog that they plan to adopt Arm’s Memory Tagging Extensions in future Android releases.

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.

Java Language Summit 2019 videos now available

The Java Language Summit 2019 took place this week, with some very interesting updates, namely:

• 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.

Lisp Badge, a tiny Lisp microcomputer

I came across the news that someone has put the effort to design and build an Arduino compatible microcontroller that can be programmed in Lisp instead of Wired (aka C++), it is called Lisp Badge.

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

Safe systems article and happy new year!

Just as the new year is arriving around the corner, I got to finalize an overview about platforms written in safe system languages since the early 60's.

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

Windows Forms, WPF and WinUI made open source!

Yesterday at Microsoft Connect(); 2018, Microsoft announced that the .NET desktop toolkits are joining .NET Core as open source.

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.

Java 10 is around the corner

Now with Java 10 release around the corner, Azul Systems, has provided on their blog a list list of 109 changes related to the new release.

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

Java 9 is finally here!

Yesterday Oracle has finally made the final version of Java 9 available, with more information available at the Oracle blog.

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.

Android Studio new GPU debugger

I have been complaining a bit too much on some Android related forums due to the GPU debugger being removed from Android Studio on the upcoming 3.0 release.

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.

Go and Rust's adoption at Oracle

Go and Rust have found their use at another IT giant R&D labs, namely Oracle.

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.

Writing safer applications with unsafe languages

So after a few months of silence, it appears security continues to be a relevant subject across native programming language forums.

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.

Cloudflare, C, Security and distributed systems

What a nice way to start my 2017's post than to talk about security!

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.

CppCon 2016 Videos and Presentations are out

This week two interesting conferences took place, CppCon 2016 and Java ONE 2016, but I will leave Java for another day.

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.

Time to focus on Android with Windows Phone's demise

Given the latest movements in the Windows Phone eco-system, I decided it isn't worth any longer to keep developing applications for the platform, namely:

• 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.

Virtual Machines Summer School 2016 videos are now available

The videos from this year's The Virtual Machines Summer School have been published and are now online.

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.

C++17 and C++ NDC track

The C++17 Committee Draft (CD) just got approved last Saturday, the 25th. There is a nice list of all the features that got approved over at Reddit.

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.

Rust 1.4 got released!

Rust just got a new release.

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.

JavaOne 2015 is ongoing!

The JavaOne 2015 started last Sunday and the keynotes are already available to watch on demand for those not able to attend.

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

C++ Core Guidelines, improving C++ safety

This week the CppCon 2015 took place, with a very important presentations done by Bjarne Stroustrup and Herb Sutter, among a few other C++ celebrities.

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.

Rust 1.3 Released

Rust version 1.3 has just been released. You can get it at the usual place

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

Videos from 2015 C++ Russia

From all talks shown at C++ Russia, two of them called my attention for:

• 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.

Swift goes open source. OpenGL gets sidestepped by Metal

Apple just announced on the WWDC 2015 Keynote that Swift is being made open source and available across multple OSes. I wonder how this will impact Rust, given the languages similarities.

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.

Windows Phone the way of OS/2 ?

For the upcoming Windows 10, Microsoft has been researching easing the life of developers from iOS and Android eco-systems to bring their applications into the Windows eco-system.

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.

DConf 2015

While the world was focused on Google IO 2015, other interesting events were happening. One of those events was DConf 2015. The developer's conference for the D programming language.

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.

Finalizing my A* Search exercise

After playing around with Qt, SDL and other attempts for a portable implementation between Android and Windows Phone, my experiment is now coming to an end.

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.

Rust has finally reached version 1.0

Time to celebrate for fans of ML languages and memory safe systems programming. The first stable version of Rust has been released!

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.

Functional Programming in Swift

Just watched a presentation from Chris Eidhof about functional programming in Swift.

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.

Rust 1.0 beta has been released!

The Rust team just announced the release of the 1.0 beta version.

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.

Make a Lisp. Polyglot tutorial for interpreters.

A recent discussion on HN made me aware of the project Make a Lisp.

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.

Rust 1.0.0.alpha.2 released

Mozilla has recently released the Rust 1.0.0.alpha.2 version.

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

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

CoreCLR has now landed on GitHub!

Microsoft just announced that the CoreCLR component for the open source.

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.

C++14 Libraries

While browsing for C++14 related information, I discovered that the C++ Rocks! website contains a list of C++14 compliant libraries.

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.

Rust on Windows.

I just managed to get Rust 0.12.0 running on Windows!

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!

CppCon videos being now made available.

The biggest C++ conference of the year, CppCon, ended a couple of weeks ago.

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.

Qt is still not quite ready for mobile. A short rant.

During the last days I have tried to use Qt with C++ to give an UI to my A* search implementation that I also could easily port between the desktop and mobiles platforms I have at my disposal.

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.

CppCon 2014 Speaker Materials

The C++ conference of the year, CppCon 2014, took place last week and it was a huge success.

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.

C++14 is now the latest C++ standard revision

This is what happens when one is on vacations.

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.

An introduction to Rust for OCaml programmers at air mozilla presentations

There is a talk at the air mozilla website about Rust for developers with ML experience, namely OCaml.

I like how Rust is evolving towards the 1.0 version.

Anil Madhavapeddy on the Mirage Cloud Operating System and the OCaml Language

A couple of months ago, Anil Madhavapeddy, one of the main drivers behind the Mirage operating system was interviewed at the Software Engineering Radio.

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.

Swift, the new language on Mac OS X and iOS ecosystems

The best announcement at this year's WWDC keynote was a new programming language developed by Apple, named Swift.

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.

Oberon article updated with new download information

The developer responsible for Oberon/A2/AOS ISO images just notified my that the location has changed.

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

Lisp, Clojure, F# set of talks

I just watched a set of talks around functional programming, all of them very interesting.

• 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.

TownGL sample available

A new graphics project, TownGL, has been added to the section.

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++.

Controling the past to direct the future

Just watched a presentation by Gilad Bracha funnily named "Onward! - Does Thought Crime Pay?".

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.

D port of the memory queue tutorial updated

The D port of the Memory Queue tutorial, queue-d , has been updated.

Writing a Nanopass Compiler

So this weekend I have been busy with Scheme and compiler related development.

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.

Incremental Parallelization of Dynamic Languages presentation

There is a very interesting presentation over at air Mozilla channel about making Racket's runtime, a Scheme dialect, capable of parallel and concurrent operations.

Making peace with Go

Long time ago I posted how disappointed I was with the decisions being taken about Go's design.

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.

HTML 5 vs native development

The persons that know me are well aware that I am really supporting of native technologies, even though I do take part in many web projects.

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.

Using Rust for OS development

I just read an article article posted on Hacker News about using Rust on an undergraduate course for operating system design.

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.

.NET gets a new JIT compiler

The .NET team at Microsoft just announced a new JIT compiler named. RyuJIT.

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.

Going Native 2013 videos now available!

The videos and slides from the sessions at Going Native 2013 are now available at Microsoft's Channel 9.

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. :)

Deep C++

Olve Maudal did a presentation about C++ undefined behaviors at the Norwegian Developers Conference 2013.

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).

A very nice introduction to Clojure

Neal Ford has done an introduction session about Clojure at the Norwegian Developers Conference 2013.

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.

The C++ Programming Language (4th Edition) just arrived!

The The C++ Programming Language book, just arrived!

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.

An Incremental Approach to Compiler Construction

Someone called my attention to a nice paper about compiler construction, called An Incremental Approach to Compiler Construction.

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.

L98 compiler has been updated and made available on GitHub

Sometime ago I discovered that the compiler project I have made available on this site was not compilable with recent versions of Java.

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.

The 2013 European LLVM Conference Videos are now available

The last LLVM conference took place on the 29/30 April, the videos and corresponding slides are now available.

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

Using Ada in embedded design

The embedded UBM Site about application development in embedded hardware, has published a newsletter about the current state of Ada for embedded development.

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.

Analyzer section updated

Keeping up the trend to update site sections related to old projects without much information, the SWI Prolog Pascal analyzer has been updated.

MapEditor updated for Visual C++ 2010

The 2D tile editor that I created for the 3P team project a few years ago, has been updated to compile against Visual C++ 2010.

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.

MSDN Patterns and Practices publishes article about C++ XAML applications

Microsoft just published an article from their Patterns and Pratices team, targeting the Windows Store (aka Metro applications) with C++ and XAML.

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

RoboVM, LLVM based ahead-of-time Java compiler, with iOS target

RoboVM is a new native code compiler for Java, targeting the iOS operating system.

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.

Niklaus Wirth talk at GTAC 2009

Welcome to my first post of 2013! I wish you had good time during the festivities and an year full of health and good times, with family and friends!.

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!

Great chefs don't use mixes

I just saw a short presentation (around 8m) from Christin Gorman about the bloat ORMs add to applications.

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.

Inventing on Principle

A very nice presentation by Bret Vitor entitled Inventing on Principle.

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.

How the Dalvik VM JIT works

I just found out the Google I/O 2010's presentation about how the Dalvik VM JIT was designed for the Android 2.2 release.

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

MDIL, also known as .NET gone native

Another announcement from Microsoft at BUILD 2012 is that for Windows Phone 8 devices, .NET applications are actually also compiled to native code.

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.

Herb Sutter announces updated C++11 support at BUILD 2012

Herb Sutter just did a presentation at BUILD 2012 presenting the new set of C++11 features to be made available with the upcomming Visual C++ 2012 November CTP release:

• 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.

Advanced iOS Development

InfoQ has placed an interesting presentation about advanced development in iOS with Objective-C.

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

Google uses Common Lisp

So it seems that after IAT Software's aquisition by Google, Google has become another company also Common Lisp.

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.

Writing a Raytracer in Common Lisp

So after some vacations, it is time to update this blog again. :)

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.

Faith, Evolution, and Programming Languages

An interesting presentation done by Philip Wadler, about the influence of functional programming in mainstream languages.

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.

Functional-Style Programming in C++

This month's MSDN Magazine has a very intersting article about doing functional programming in C++, while taking advantage of the new C++11 standard.

Thinking in Functional Style using F# and (some) C#

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.

Functional Programming in the Wild

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.

WWDC 2012 videos and slides now available

I just noticed that the presentation materials from WWDC 2012 are now available.

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 C++Now! 2012, former BoostCon videos now available

Last month I blogged that the papers from The C++Now! 2012 were made available, with the videos following some time later.

The videos are now available. Enjoy.

Having fun with Qt and C++

I just got asked to develop a desktop application.

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.

Microsoft caves in for Visual Studio Express version for Windows

As it seems Microsft has given up on their plans to have the Visual Studio Express versions target only Metro in the upcoming Windows 8.

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.

LINQ and Rx for C++ from Microsoft

Microsoft is developing libraries to add LINQ and Reactive Extensions to their C++ compiler.

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.

Lots of nice C++ stuff

If you are a bit bored on the weekend and feel like picking up speed about C++11, C++ on Windows 8, or latest C++ freebies from Facebook, then there are lots of cool stuff to read about.

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.

A very good introduction to Monads with Clojure

To keep on a Lisp note, there is a very good presentation from Carin Meier on InfoQ about the Identity, Maybe and State monads in Clojure.

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.

Deploying a Common Lisp web application

Just found out a nice tutorial on how to deploy a web application to Heroku.

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

Microsof is looking for compiler developers

Herb Sutter just mentioned on his blog, that Microsoft is looking for engineers to join the Visual C++ team. You can find more information here.

Good luck, in case you apply for the job.

Do not rely on proprietary programming languages for your business.

The idea for this post originated after I started following the Oracle vs Google Java litigation case, as well as, discussing about it on OSnews.

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.

Betting on the wrong horse

While reading the Go tweeter feed I've discovered a company called Wakoopa, decided to move their code from Ruby to C, after a failed attempt to use Go. As described on the company blog.

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.

WebGL Stats Web Site

I just discovered the WebGL Stats web site. Quite handy to know which WebGL are generaly available on most people computers.

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

Two new C++ videos available on Channel 9

I just come across two C++ videos about modern C++ on Microsoft's channel 9 web site. Even thought I don't agree 100% with everything Herb Sutter says on the first video, I have to agree that C++ is the best language to use nowadays for native performance.

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.

New C++ programming article

The other day I was reading some exercises the game studios do on their job interviews and decided to have my go at one of such exercises.

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.

Sony is using C#/.NET for PlayStation Suite/PS Vita

Thanks to Mono's Monologue feed, I just discovered that Sony is investing into C# and .NET for their new PlayStation Suite and PS Vita platforms.

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.

Having fun with Android

Last weekend I have spent some time playing around with Android for a small demo, and it was very interesting.

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.

Disappointment with what Microsoft is doing to C++

As many developers out there I was eagerly waiting for the BUILD conference and what changes it could bring to the C++ developers on Windows.

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.

The return of native code

A few weeks ago there was an article about the new C++11 standard and the ressurgence of native code.

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.

Mini-ML converted to F#

Back in 1997, I did a Mini-ML interpreter in Caml together with a very good friend of mine for the Programming Languages course, at the University.

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!.

Ceylon

So I finally managed to live through the Ceylon presentation now available at InfoQ.

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.

C++ Renaissance

After bashing a bit on Microsoft on my last posts, here comes again a bit of praise. :)

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!".

In praise of C++ and Linux

The new London Stock Exchange software has finally gone live and is working without any major issue.

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.

Why Nokia? Why?!

So against all odds, Nokia did realy decide to make Windows Phone 7 the main OS for its mobiles.

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.

STL C++ tutorials at MSDN

Stephan T. Lavavej from Microsoft Visual C++ Libraries team has made a series of tutorials about how to use the STL, which are quite interesting.

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.

Android 2.3 (Gingerbread) has been announced

The new features of the upcoming Android 2.3 are now public. Just go over to the Android release announment to know more about it.

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.

Haskell has a redesigned web site

The Haskell official web site has now a new design. You can check the new design here.

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.

Space Architects

Some videos of Oredev 2010 are now available.

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.

Microsoft open sources F#!

Microsoft just announced that they made the source code for the F# compiler available under the Apache 2.0 License. The has been reported by Don Syme on his blog.

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#.

Apple deprecates Java on MacOS X

Apple just decided to stop investing on Java for newer MacOS X releases, as stated on their release notes of MacOS X 10.6 Update 3 and MacOS X 10.5 Update 8.

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.

Quite a few updates from the C++ world

Many people deslike C++, even I have a love/hate relationship with it, but I also think that there is no other mainstream language that can replace it for the time being.

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.

What Killed Smalltalk Could Kill Ruby, Too

I just discovered a very interesting video from the RailsConf 09, discussing the reasons that kept Smalltalk out of the enterprise and how they could happen again with Ruby.

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. :)

HTC Desire arrived! Sorry for the downtime

First of all, let me excuse myself for the downtime on the last days. I had a problem with the domain, which made the site inaccessible.

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

HTC Desire on its way

So I finally decided to order my Android based mobile, and ended up chosing a HTC Desire.

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?

Symbian is still not developer friendly enough

This week I decided to try to use the new Nokia Qt SDK and check how friendly it is now to develop for Symbian.

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.

Why Oracle!? Why Oracle?!

It had to happen sonner or later. So the last Oracle's move concerning Java's future was to process Google over Java patents on their Dalvik VM. As you can now read all over the Internet.

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.

No Go for Go!

I have been playing around with the latest programming language, whose development is sponsorend by Google, Go.

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.

Google releases App Inventor for Android

If you are old enough you might remeber a nice point-and-click development environment for Macintosh called Hypercard. This way of developing applications has been the foundation of a few RAD environments like Visual Basic or Delphi.

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.

Java 7 closure's syntax is awfull

The first version of the upcoming closure functionality for Java 7 has just been made available on the OpenJDK repositories. You can read more about it on this InfoQ article.

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.

Intel releases Intel Concurrent Collections for Haskell

Intel just made a big step in increasing Haskell's visibility in the industry, by releasing the first version of their concurrent libraries for Haskell.

Now available at Intel's Blog.

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

Modern OpenGL tutorial

Joe Groff from Durian Software has posted an online tutorial explaining how to make use of modern OpenGL programming techniques. You can have a look at it here

Have fun updating your OpenGL skills.

Bye Sony

As some of you might recall, I had mixed feelings for the Linux support provided by Sony on their PS3 games console. Their lack of support for something similar to the PS2 Linux always kept me away from buying a PS3.

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.

Finally OpenGL 3.2 on my laptop thanks to NVidia

It has been a long time since my last post. So before I say anything else, have a very nice 2010 full of only good things in life and in all areas of your life better as 2009 was.

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.

GDC Europe 2009

This week I was attending the GDC Europe 2009, that took place in Cologne. It used to take place in Leipzig, but now the event organizers have move it to Cologne. Since it is just 60Km away from Dusseldorf, I had to attend it as well.

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.

OpenGL 3.2 got released

Great news, even though I came a bit late to write about them. The Khronos group has announced on Monday the new revision of the OpenGL standard.

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.

Concepts dropped from C++0x

Today is a sad day for the C++ community, as the news about Concepts being dropped from the upcoming standard got known.

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.

Article: Interviewing Java Developers With Tears in My Eyes

Nice article about interviewing developers that don't get anything about their real job.

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.

Presentations from Nokia Developer Summit 2009 now online

Nokia has put the presentations from the latest Nokia Developer Summit online. And I already went through them, and have found what seems to be a hidden message.

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.

2009 Lang.NET Symposium Videos

Uff! It has been already a month since my last update, I really need to try be more active.

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.

OpenGL 3.1 Specification got released

Today at GDC 2009, Khronos announced the new specification for OpenGL. This is really good news. After the desilusion that many of us had with the 3.0 specification, I can say that I am really impressed with what they managed to deliver in 6 months.

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.

Getting ready to release an updated site version

I am playing around with PHP and jQuery in order to update the remaining parts of the site that still look a bit too ugly and have the old look.

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

FOSDEM

I am attending for the first time FOSDEM. So far it has been quite interesting to see what the morning talks were talking about the Open Source community spirit.

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.

Getting a proper development enviroment for F#

If you want to play around with F# but do not want to be left with just the command line compiler and a text editor, there is a solution.

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#. :)

Windows 7

I just installed Windows 7 on my laptop and I am quite impressed with it.

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. :)

Orion Tear

While I was in vacations in Portugal, I saw a program about Orion Tear, a portuguese 3D movie made with open source tools.

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.

State of Linux game development

Because of Jeff's blog entry about how important it is for the game studios to support Mac OSX and Linux, I have found out a blog discussing the state of affairs of Linux game development.

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!

xubuntu disappoints on old laptop

My father has an old Toshiba 4070 CDT laptop, with 192 MB RAM and a Celeron 300 Mhz processor. A perfect candidate to use a Linux distribution and thus improve its current usage. Since it is already an adventure to run Windows 2000 plus an anti-virus on the system.

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.

No Closures on Java 7

It has been confirmed at this year's Devoxx08 that closures won't be part of Java 7. As presented by Mark Reinhold.

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?

OpenCL 1.0 specification is out

The specification for the OpenCL has been announced today on SC08.

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.

Linux almost back to my Laptop

This week I have decided to buy an extra harddrive and play around with the idea of having Linux installed into it.

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.

Orishas!!!

I went yesterday with two friends to Frankfurt, where we had the opportunity to enjoy a very nice concert from Orishas.

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.

Sony and PS3 Linux

I did complain already a few times about what Sony is allowing Linux to do on the Playstation 3.

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?

Meeting an old friend

Sometimes life is really surprising. This weekend I did not had big plans except for something going on, on Saturday, but even that was kind of changed on the last minute.

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.

New Apple Laptops! Or not. :(

Apple has released this Tuesday a new set of laptops, and they are really beatiful to look at.

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?

Cla

Cla are one of my favorite Portuguese bands. Yesterday I had the opportunity to see them alive after several years of absence from their concerts.

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

FADA

Last week, during my vacations, I was able to attend the Theatre festival FADA in Aveiro, Portugal. It was really nice to watch all the Theatre groups that attended the festival. I hope that my hometown gets to see more of such events.

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

Sun Certified Java Programmer

So, now I am a certified Java developer as well!

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 :)

Carmack's comments on Linux gamming

John Carmack has commented his view on the Linux gamming, on the last Quakecon convention. You can read his comments on the Linux Gamming site.

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.

OpenGL 3.0! Is here, kind of.

Last monday, it has finally communicated to the community, the new OpenGL 3.0 standard. However it ended up being more like a OpenGL 2.2 than what has been promissed to the community.

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.

Love Parade: The Good, Bad and Ugly

Yesterday it was time to go for my first time to the Love Parade. It was great! I already went to another Parade like events, specially while living in Switzerland, but this was the first time at the real one.

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.

SCRUM applied to game development

There is a nice article in Gamasutra about the Top 10 pitfalls Using Scrumm, while applying it to the game development process.

Java Monkey Engine site renewed!

I have been tracking the Java Monkey Engine project for quite sometime. Unfortunely on the last months, not much care has been taken for the site. Leaving many visitors to wonder if the project was still alive.

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.

XNA 3.0 CTP is out!

Finally the new XNA for Visual Studio 2008 is available. This is only the technical preview, the final version should be made available at the begining of the Summer time.

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.

Spain is looking for Engineers

It seems that Spain is lacking 25 000 Engineers, according to El Pais. If you fancy working in Spain, now might be the time to look for an opportunity.

Portugal's Usage Manual

Recently I have bought the book Gebrauchsanweisung fur Portugal. Sorry for not providing a direct URL but PHP's simple_xml() seems to have problems with the Amazon URL.

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.

Spieleentwickler Treffen NRW

Yesterday, I attended the 4th Spieleentwickler Treffen NRW at the Media Design Hochschuele, here in Dusseldorf. It was very nice, with lots of interesting persons full of desire to make fun games.

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

Back from vacations

I am finally back to Dusseldorf after some vacations where I travelled to Vienna, Amersfoot and Amesterdam.

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.

New Site Design

Finally after several years with the same design, I have decided to refresh the way the site looks. Thanks to owsd I could quickly change it. I might still change the template but I also like this one.

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.

NVidia's GDC 2008 Papers are now Available

For those of you that aren't always tracking down all the comunications from our beloved graphics hardware developers, NVidia has just published the papers from their talks at GDC 2008. You can get them here.

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

Talks from Lang.NET available

The slides from the 2008 Lang.NET Symposium are now available. The downside is that you need to install Silverlight in order to see them. I really would like that Microsoft would be more standards friendly instead of having their own standards for everything.

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

Super Concert!

Yesterday I went to the Phoneheads concert together with the Dusseldorfs Orchestra. That was a really nice concert!

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.

Microsoft's Channel 9

This weekend I spent a great deal of time watching Channel 9 videos. Surely you get a lot of Microsoft propaganda, but they also have very interesting subjects with developers/researchers working outside Microsoft world.

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

Portuguese Game Studio on the News

I just saw an article at the Develop Magazine about a Portuguese studio using the Gamebryo engine.

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.

Helau! Carnaval is in Town!

Hi! Currently we are in Carnaval, and it is pretty big here in Germany. So we are having lots of partys to attend to. :)

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.

Software Engineering Podcasts

Hi! So the year already goes far advanced for my first 2008 entry, but since we are still in January. Happy New Year! :)

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.

Merry Christmas and a Happy New Year!!

Even though I'm posting this entry after Christmas day, we are still on Christmas Hollidays. So enjoy the season and all the best for 2008!

Portuguese Winner on the NVidia Shader Contest

I just discovered that one of the winners from the Shade Your World competition is Portuguese!

Bye Symbian C++

You guys might remember how happy I was last year with the possibilty of trying out C++ on Symbian mobiles.

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.

A little Ruby

Due to the increased interest in the Ruby programming language, I took some time to play with the language during a business travel last week.

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.

The increase in functional programming

Last week I came to know a little know fact that pleased me. Microsoft is turning F# into a product, as noticed in Don Syme's blog.

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. :)

C++0x, will anyone care?

I started programming in C++, back in 1992. At the time there were lots of C++ related magazines discussing the language along with the standardization process. The C++ Report and The C/C++ Users Journal became part of my monthly reading.

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.

PS3 at 400 euros. At what price?

Sony made the announcement of a PS3 at 400 euros. We should probably be happy with it, since even I paid more than that for my PS2. But I'm personally not that happy.

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.

Animation Generator available

I have made a small Java utility to convert Sony's Multiburst image files into a more convenient file format. Which currently means animated GIF files. Just follow the header link to get the utility.

Vacations!

I'm still on vacations, now in Aveiro, after a well spent week in Lisbon.

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.

Got Approved!

Just got the result of my german exam that I did in may. Yes I know that is long time ago however the exams are corrected all together in Munich so they take sometime to get corrected. But I can say that I did pass the exam and now have officially C1 german level! :)

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.

Back from Finland

I'm now back in Dusseldorf after a short stay in Helsiki due to one of our projects. Since I had some time after work to walk around the city, I took the oportunity to take some pictures of the city. Specially this time of the year, since they still almost have no night. You can have a look at them here.

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. :)

Blog finally updated!

Hello! Those of you that were coming to my blog for the past few months may have thought that the site was dead. Actually I have done a few updates, but nothing much. Now I have using PHP5 for the blog part, and for my photo gallery. Well the photo gallery is only visible to my friends but it is a very important part of the site.

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.

Busta Rhymes concert

Last Friday I went to Busta Rhymes' concert here in Dusseldorf. It was nice to be able to watch him live, but the concert felt somehow short. Somehow it seems that more time was spent on the bands that played before him than on his concert.

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

Easter Time

Hi everyone. I wish you all an Happy Easter.

Games for Mobiles, is it really worth it?

I have been a long time fan of J2ME games, always hoping for them to get better but that doesn't seem to be the case. Currently mobile games are a good busines with lots of people downloading games to play on their mobiles mostly while commuting. And lots of them are really cool, however there is one big disavantage to them while comparing to a PSP or DS. Lack of proper controls.

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.

Noubless Oblige

Yesterday at Salon des Amateurs I was able to get to know a very cool Drum and Bass band. I don't know if they will support my understanding of their music style, but they are really cool nontheless. Check them out at their web site.

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

Helau! Karneval!

So it is time again for Carnaval in Germany. Here in NRW the country will surely almost stop until next Wednesday. If you are around just be prepared to take part into the action, or to run away if this is not your kind of thing. :)

Better support for Symbian

It seems that the Symbian consortium is finally realizing the pain it is to program for the Symbian OS. So they are releasing POSIX support for the OS. The project name is known as Open C.

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

Linux out again :(

It's been a long time since my last blog entry, so first of all I take the oportunity to wish you all a Happy New Year, even though we are already in February.

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.

Linux is back in. Time for XBox 360?

So after some experiments I was able to use Mandriva 2007 and also Fedora Core 6. Both seem to support most of the laptop, exception made to the usual Winmodem stuff and maybe the WiFi system. Anyway Mandriva default X installation kept on hanging, so now I'm trying my luck with Fedora.

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?

Time to drop Linux out of my Laptop?

This title may seem bombastic to my friends that know me as a Unix lover even though I also work with Microsoft tools every now and then. The problem is that we are currently in 2006 and after several experiments, I still haven't found a distribution that supports all the hardware in my Laptop.

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.

Some new stuff

It has been a while since I lasted posted here. Lots of stuff have been happening. For a starters I'm back to the VHS, now at medium level B2. Yep, that's right I passed my "Deutsch als Fremdsprache" exam! :)

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.

Mera Luna

This weekend I attended Mera Luna and it was very nice. I was afraid of attending it because of the weather conditions. But in the end it did not rain and I manage to see some interesting bands. And I also enjoyed meeting my friends.

So see you next year Mera Luna!

See you in Lisbon

A portuguese friend that I met in Dusseldorf just returned home this weekend. It was sad to see a friend go. In one hand I felt sad because it is always a sad to see a friend leave. But on the other hand I also understand that each one has to live its own life.

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

World Cup is over

So today it's the last day of the World Cup. It was a very interesting World Cup. Specially if you were lucky enough to live in Germany. It was very nice to live thru all the ambiance that surrounds an international event like this one.

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. :)

Meetin Paris

I just came back from Paris after spending some time there for the MeetIn convention. I must say that it was great and I enjoyed a lot all the activities that the MeetIn Paris members organized. It was also great to get to know so many nice people from all over the world.

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.

Barcelona!

My favorite spanish football team just manage to win the Champions League. It might not have been a super match, but in the end they managed to succeed. So "Felicitaciones Barca!".

Friends

Last week a friend of mine had to go back to her country. Someone that I got to know last year and became a good friend of mine, and hopefully we'll keep on touch.

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!

How it is possible!?!

Sometimes is incredible how people put up with buggy IDEs. I've been trying to generate EJB mapping code with the mapping tool from a very well know IDE, and the generation keeps on failing due to some strange IDE bugs. This task is keeping me busy for a week already. How can big companies release such a buggy products?!

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.

Juanes' Concert

Yesterday I went with a friend to the Juanes' Concert here in Dusseldorf. It was really cool. We took lots of pictures and he played most of his hits. In the end it was a very good concert. My only complain is that the concert could have been a bit longer.

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

Cebit 2006 Video and Tcl

I just got an email from a friend telling me that one his Cebit videos, just made its way to the Looking Glass web site. Congratulations Oliver!

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!

Cebit 2006

This weekend I traveled together with a friend to my first Cebit's visit. It was kind of cool to attend Cebit. The exibithion was quite big and we got to see some cool stuff first hand. I was pleased to see a section with old computers. I consider it a travel into childihood.

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.

Cool Concert last night!

Yesterday, I've attend the Misia's concert here in Dusseldof. It was a very nice concert. A big part of the audience was Portuguese, but many Germans were also there. And I can say that everyone enjoyed the concert. We even had 3 encores! Good luck for the next concerts, Misia.

Happy New Year

It's a bit late, but I guess it's still on time. HAPPY NEW YEAR everyone!

First snowfall in Dusseldorf

The first snow of 2005 Winter has just arrived! I managed to take some photos from my house.

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

Petzold's article

I just read a very nice article from Charles Petzold about the complexity of todays IDEs. Even though is talk was target to Visual Studio, I think we can apply the same reasoning to other IDEs as well.

Back to Germany

I am back to Germany, after some vacations in Portugal and decided to update the site as well.

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?!

SIC is now available outside Portugal!

Hurray! I just discovered that the Portuguese TV network SIC is now available outside Portugal. MUITO OBRIGADO!

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

Oita Cinema gets a new life!

I've just learned that one of my favorite cinemas back home is getting a new life thanks to the city's cinema club. Sorry but they only have information in Portuguese.

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.

M'era Luna

Last weekend I went to the M'era Luna festival to meet some friends and enjoy the music festival.

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.

Bukovina Club

This Saturday I went to a concert here in Salon des Amateurs that was very good. So if you like musicians like Kusturica, take a look at Bukovina web site. If you follow the link you will get to hear some samples.

Trip to Bruges

The last weekend I was in Bruges, very nice town. I strongly advise you to visit it.

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.

Spanish night

Yesterday I went to a Spanish night here at Zakk. Very nice party and I recomend it.

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. :)

Another sad day

So when the world thinks that we are safe, we get another attack just to remind us that it isn't so. I can't understand what makes these guys make this sort of things.

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

Blogs and other stuff

I'm really thinking about improving this blog section. But alas, real life keeps holding my progress. So probably in a few more months before the new site version becomes available.

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.

New site engine part 2 and Karneval

I'm playing around with rails and really like it. It makes me remeber of a framework that I used to work with while at Altitude Software. It shares many of the same concepts but used Tcl instead.

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.

Ideas for a new site engine

I'm starting to be fed up of using these XML/XSLT files for the web site without much support from something else. So I've decided to automate the generation of these files with something like PHP or Perl. What I want is the ability to add new content using a browser and nothing else. I already looked into some PHP CMS systems like Mambo and XOOPS but they seem overkill for my simple site.

Help the victims of the Tsunami

What can I say? The amount of images that we can see from the area are nothing compared to the suffering and losses that Asien people are going thru now. So just help the international organizations so they can help them.

Moving into Dusseldorf

Even though I am making this entry, the 6th of January, I wanted to leave the date that I officially moved here. :)

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.

Updated the Delphi's Lex/Yacc entry

The entry for the Lex/Yacc tool for Delphi has been updated. The owner changed the web site location.

Tactics being tested in real hardware!

I was finally able to download tactics into my mobile phone, a Nokia 3510i. I'm now in the process of tailoring the code so that the game makes the best use of the phone.

Eli entry updated

The Eli entry in Compilers Toolkits, has been updated. My personal information was also updated.

Tactics ported to Nokia Series 60

The tactics J2ME game has been ported to the Nookia Series 60 platform.

PyGgy - New compilers section entry

Information about the PyGgy parser/lexer generator was added to the compilers section.

MapEditor was updated

Finally I've managed to fixe some of the help files in the MapEditor.

A new game is available

A simple tanks game that I started developing when Vodafone anounced their game competition has been added to the games section.

It is called tactics.

A gallery generator in Python

Added a small Python script that generates web galleries from a set of image files.

Flipcode talks about my port

Today I saw that Flipcode has a news about my 'The Art of Demomaking' port. This was really great. :)

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

The Art of Demomaking ports updated(again)

The missing samples, ta-demo15 & 16 were finally added.

The Art of Demomaking ports updated

The code now compiles with gcc 3.2.X in the latest Linux distributions.

The Art of Demomaking ports updated

The timer related code of the ports has been updated.

The Art of Demomaking ported to SDL

The Alex Champandard's tutorial samples have been ported to SDL.

RSS now supported

My first RSS version goes live!

New game added

A new game has been added to games section.

Parser/Scan Generators Updated

The Delphi Parser Generator has been added to the Parser/Scan Generators section.

AI article now online

My AI article is now online at the AI Depot

SableCC entry updated

The SableCC entry in the Compilers Toolkits section has been updated.

Checkers localized

Checkers has been localized to English and Portuguese.

Checkers goes LGPL

Checkers is now under LGPL.

Checkers interface gets a new look

The Java version of checkers has been upgraded from AWT to Swing. Nothing like bringing the interface up to date. :)

Compilers section updated

Added new entries to the Parser/Scan Generators and Tree Transformations sections.

New article

Added the article that I submited to a contest in AI Depot. It is available in the tutorials section of the games area.

A games section is now available

Added a new section, entitled Games. Moved the games that were available in the Graphics section to the new section.

FNC-2 entry is updated

The FNC-2 entry in the Attribute Grammars section has been updated.

New compilers information available

A new entry in the compilers section is available! It contains information about The Parsers and Scanners tools that are available on the Net.

Programming in GNOME with C++

The tutorials section of graphics has been created. It has an article about programming in GNOME with the gtkmm/gnomme framework.

SharpCheckers was updated

SharpCheckers has been updated to the .Net release edition.

Checkers now in .Net

It's been a long time since I've updated the site. Well I guess that is what happens when you have a site as an hobby and not much free time. :(

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 !

New hosting

Finally I've decided to get myself a domain and the ability to script my site the way I want to.

It's been a while since I last updated the site, so I added a small checkers game that I done a few years ago. I am in the process of learning C# and WinForms, so stay tuned for an updated version of the game.

The Discovering C++ document has been updated!

C++ programming document

I realized that there are many C++ developers that don't know anything about how different is standard C++ from the one they are using. So I decided to create a FAQ with information targeted at them.

A MapEditor

Finally I got some free time and added an entry for the MapEditor. An editor for 2D tile based games.

CV Update

Well, instead of updating my online CV on Friday, I am updating it today.

New CV versions

OK, I have updated my CV in the authors section. Now there are RTF and PDF versions. The online version will be updated tomorrow.

Fixed folder's names

Apparently some of the folders were misspelled :((. But that's solved now, thanks for your patience.

A new version appears

Finally the third version of Programmers' Toolbox is up and running :). A section about parsers and scanners is missing because is being updated, but it will be added very soon.

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