Contents tagged with English
-
WebAssembly – A new Hope
Recently, WebAssembly was announced, a new standard that defines a binary format and execution model for the Web. With Google, Mozilla, Microsoft and others voicing their support, my first thought was: Wow, so there is actually hope to get rid of JavaScript someday!
In this blog post I’ll explain why I think WebAssembly is such a big step in the right direction, even if it’s something that won’t have an immediate impact.
What’s the problem with JavaScript, anyway?
JavaScript is a programming language that has quirks (see Seven JavaScript Quirks I Wish I’d Known About or JavaScript garden), lacks important features (e.g. proper arithmetic data types) and isn’t type safe (by design).
All this doesn’t matter for JavaScript’s original purpose – writing a few lines of script code. In fact, the dynamic nature of JavaScript, i.e. being able to add object properties or change data types on the fly, enables some pretty elegant solutions.
But writing large amounts of JavaScript in a team of average developers comes with a risk that is higher than in other languages. Bugs that the compiler for a typed language would catch immediately can remain unnoticed for a long time. Renaming identifiers (via find-and-replace in a text editor) or refactoring code can be downright dangerous. Anders Hejlsberg puts it this way: “[…] you can write large programs in JavaScript. You just can’t maintain them.”.
So why are people using JavaScript?
- JavaScript in the browser (used in conjunction with other web technologies) enables highly responsive, cross-platform, zero-deployment applications…
- …without any additional client installation (most would consider their favorite non-IE-browser as part of the “basic operating system setup” before any work can be done on a new computer) …
- … and is good enough for developing almost any kind of application – at least given enough time, budget and/or determination.
The problem: this “good enough” is an enormous hurdle for any alternative technology. At this point in time, it’s totally unrealistic that a completely new technology will magically appear and win the uphill battle to be available on all platforms, with the same reach as JavaScript-enabled web browsers.
Fact is, JavaScript (plus other web tech) won. Some people are perfectly fine with this, others (me included) are a bit skeptical what this means for the future of software development – to put it mildly.
Is JavaScript the QWERTY of programming languages?
I started programming in 1983 and since then I’ve witnessed incredible progress. From writing Z80 code that fit into a few kilobytes of RAM to simply using a component without caring, or even knowing, what language it was written in. And then, at some point, writing lots of code using a scripting language (using a document markup language to create application UIs, but that’s another story) became state-of-the-art. I thought we’d be much further in 2015.
Ok, if replacing the JavaScript ecosystem with something completely new isn’t a realistic option, what can be done to improve the current situation for software developers?
Option #1: Make JavaScript better
JavaScript can be improved if all major players agree on the how, when and what. This can happen (see ECMAScript 2015), but sometimes it doesn’t (see ECMAScript 4). Improving a standard takes time, and it’s definitely not a playground for “let’s try this crazy idea and see how it works out when all browser have it”. Plus, some language characteristics simply cannot be changed without breaking a lot of existing code.
Of course, this “you want to turn X into Y, but you cannot change X and don’t want to start from scratch” is nothing new in the world of programming languages. It’s a recurring pattern that if people have an idea for a programming language [feature] and are not in the position to write a full-blown compiler/interpreter and the matching runtime environment, they choose the route of more or less advanced a preprocessor.
Which is exactly what happened with JavaScript, too.
Option #2: Compile-to-JavaScript
There are quite a few source-to-source compilers (see List of languages that compile to JS). These “transpilers” let you write programs in one language and translate the source code to another – JavaScript.
In the early days, debugging was kind of painful, because you had to debug the resulting JavaScript. Now that browsers support source maps, the debugging story is straightforward: You step through the original source code, and the debugger keeps track of where program execution is in the JavaScript code behind the scenes.
Note that source maps are not magic; they can tell the JavaScript debugger the original filename, line and column. If you want on-the-fly inspection of variables, the source language shouldn’t be too far away from JavaScript and its concepts (see the article “Beyond Source Maps” for more on source maps).
TypeScript is a language that is close to JavaScript by design, extending it e.g. by offering optional typing. The TypeScript compiler translates the source code to idiomatic JavaScript code, i.e. code that a JavaScript developer following certain patterns would write by hand. TypeScript improves the developer experience, but cannot overcome inherent limits of JavaScript. The performance is determined by how fast the JavaScript engine executes JavaScript, obviously, and you still don’t get better (native) arithmetic data types.
asm.js is “a strict subset of JavaScript that can be used as a low-level, efficient target language for compilers” (quote from the spec). So this is not a language intended to be written by human developers. Instead, a compiler like emscripten compiles a source language to “JavaScript-as-assembly” code. The code still runs in any browser, but for good performance you need an engine that either knows about asm.js or at least can achieve good performance from the JavaScript code that tries to avoid type conversions and garbage collections.
There are a couple of things to keep in mind regarding asm.js:
- Currently it is intended for statically-typed languages like C/C++ that use manual memory management. For other languages, you either have to translate the source to e.g. C first, or even translate the whole interpreter/runtime environment.
- Browser vendors have to adapt their JavaScript engines for significant performance gains.
- The resulting JavaScript code can be pretty large, so parsing the code on the client becomes a bottleneck (sending the code over the write can be an issue in certain scenarios, too).
- Debugging is a problem, because the information stored in source maps is not sufficient.
Finally, what’s WebAssembly about?
WebAssembly can be thought of as an evolution of asm.js, to have “something” that can execute low-level code which can be optimized and precompiled. The central idea is transport the code in a binary format instead of (mis-)using JavaScript. This results in smaller file sizes and removes the parsing of source code on the client (good for mobile or IoT).
This “something” will be part of JavaScript engines some day. Part of the high-level goals is to have a polyfill at least for the first step, the minimum viable product, which enables the MVP to run on existing browsers, but I’m not sure how important this will be in practice.
It is important to note that at first, WebAssembly won’t be a general purpose compilation target for languages other than C/C++. The idea is to work incrementally, gain experience and collect feedback. The long-term vision does contain support for garbage-collected languages, though. Looking at the long list of To-dos it becomes clear that a lot of work is waiting to be done (including better source maps).
Does WebAssembly have a chance?
Judging from the collaboration of the big players alone, I’d say yes. Also important: Both the vision and the incremental approach to get there sound reasonable, clearly trying to avoid XHTML 2‘s “death by overambitious design”. WebAssembly is not about throwing away or replacing JavaScript engines. WebAssembly will be added to the engines, which helps interop and means that low-level infrastructure can be reused.
Again, things will take time, and the first versions will not be suitable for all scenarios. In the long run (we’re talking years, not months), though, WebAssembly is very promising. If you have a general purpose engine/virtual machine in every browser, developers are free to use whatever language they want because the language matters only at compile time, not at runtime.
And this is the point where we’ll be able to get rid of JavaScript.
-
Emaroo 2.5.0 Released
Emaroo is a free utility for browsing most recently used (MRU) lists of programs like Visual Studio, Word, Excel, PowerPoint and more. Quickly open files, jump to their folder in Windows Explorer, copy them (and their path) to the clipboard - all with just a few keystrokes or mouse clicks.
You can download Emaroo 2.5.0 on www.roland-weigelt.de/emaroo
Getting Started
- Download, unzip and run the MSI
- Start Emaroo (e.g. by hitting the Windows key, typing “Emaroo” and pressing Enter)
- Tip: Right-click the “Emaroo” task bar item and choose “Pin this program to the task bar” from the context menu. If you drag the task bar item to the left-most position, you can start Emaroo anytime by hitting Win+1.
- Press F1 for a quick reference of the features.
What’s New?
- Added: Support for Visual Studio Code (most recently used files and directories).
- Added: For IrfanView, now both most recently used files and directories are shown.
- Added: Individual applications can be hidden on the new configuration tab.
- Fixed: Error message when cancelling a UAC prompt
- Fixed: Crash at startup on some first-time installations
-
OzCode – or: Why it’s Always a Good Idea to Visit the Exhibitor Booths at a Conference
You surely have come across the situation when you visit a developer conference with an exhibition area, walk past a booth, see the company logo, read claims about increased productivity and think “ah, whatever”.
Tip: If you see something that remotely touches your area of work or general interest, do yourself a favor and ask for a product demo. You never know what you may miss.
I’m at the Microsoft Build conference right now and I stumbled across a fine product that promised increased productivity when debugging C# code – and actually delivers.
OzCode (http://www.oz-code.com/) is a Visual Studio add-in by the company CodeValue. They have videos on their website, showing off the individual features. Each video is just a couple of minutes and gets to the point really quick.
I downloaded the trial version, used it on the application I’m working on in my spare time and the “Reveal” feature alone made me regret I haven’t come across this add-in earlier.
OzCode doesn’t interfere with ReSharper (the OzCode devs are ReSharper users themselves), the pricing is reasonable and they offer free licenses to open source developers and Microsoft MVPs. Definitely worth a look!
-
Emaroo 2.2.0 Released
Emaroo is a free utility for browsing most recently used (MRU) lists of programs like Visual Studio, Word, Excel, PowerPoint and more. Quickly open files, jump to their folder in Windows Explorer, copy them (and their path) to the clipboard - all with just a few keystrokes or mouse clicks.
You can download Emaroo 2.2.0 on www.roland-weigelt.de/emaroo.
Getting Started
- Download, unzip and run the MSI
- Start Emaroo (e.g. by hitting the Windows key, typing “Emaroo” and pressing Enter)
- Tip: Right-click the “Emaroo” task bar item and choose “Pin this program to the task bar” from the context menu. If you drag the task bar item to the left-most position, you can start Emaroo anytime by hitting Win+1.
- Press F1 for a quick reference of the features.
What’s New?
- Added: Files can be dragged outside the application window (e.g. to copy them to a folder or open them in another application). This will not affect the most recently used list.
- Fixed: Context menu not updating items to match the "always open as administrator" option when using the menu key on the keyboard.
- Fixed: Bitmap cache files of old versions not being removed.
You can read the complete version history on the Emaroo website.
-
Emaroo 2.1.0 Released
Emaroo is a free utility for browsing most recently used (MRU) lists of programs like Visual Studio, Word, Excel, PowerPoint and more. Quickly open files, jump to their folder in Windows Explorer, copy them (and their path) to the clipboard - all with just a few keystrokes or mouse clicks.
You can download Emaroo 2.1.0 on www.roland-weigelt.de/emaroo.
Getting Started
- Download, unzip and run the MSI
- Start Emaroo (e.g. by hitting the Windows key, typing “Emaroo” and pressing Enter)
- Tip: Right-click the “Emaroo” task bar item and choose “Pin this program to the task bar” from the context menu. If you drag the task bar item to the left-most position, you can start Emaroo anytime by hitting Win+1.
- Press F1 for a quick reference of the features.
What’s New?
Version 2.1.0 adds an option in the context menu for Visual Studio solutions to always open a solution as administrator:
Checking the option adds a small file to the directory where the solution is located; if the solution is named e.g. Example.sln, the marker file will be named Example.sln.openAsAdmin. So this transfers to other systems when you check the file into source control. Unchecking the option deletes the file (and vice versa).
You can read the complete version history on the Emaroo website.
-
Emaroo 2.0.0 Released
Emaroo is a free utility for browsing most recently used (MRU) lists of applications like Visual Studio, Word, Excel, PowerPoint and more. Quickly open files, jump to their folder in Windows Explorer, copy them (and their path) to the clipboard - all with just a few keystrokes or mouse clicks.
Emaroo 2.0.0 adds support for Illustrator (CS6/CC/CC2014), lets you now open files in a text editor, copy files to the clipboard (for pasting them into an Explorer window) and fixes some UI glitches on systems with high DPI settings.
You can download Emaroo 2.0.0 on www.roland-weigelt.de/emaroo.
For examples of how Emaroo can speed up working with files, take a look at the “Why Emaroo?” section of the blog post announcing version 1.4.0.
-
.NET Rocks! – on Fusion!
I’ve been following the “.NET Rocks!” podcasts of Carl Franklin and Richard Campbell for many years now. They’ve had virtually all well-known names of the .NET development community on the show and hearing the podcasts is a good way to kill time on a flight, in the gym or elsewhere.
From time to time they feature so-called “GeekOut” shows on topics other than software development. In recent months they had three shows on fusion science:
- Show #1013: Fusion Power GeekOut
- Show #1022: Fusion Power GeekOut #2
- Show #1037: Cold Fusion GeekOut
The two shows on “hot” fusion were both fascinating and sobering at the same time, as the promise of “clean” energy seems to be far away – not only for “we haven’t figured that details out yet” reasons, but because of some very hard-core problems that are more or less being pushed back and ignored in order not to disturb the big machinery that is “Big Science”.
The third show looks back at the circumstances of the original announcement and mentions current work by Mitsubishi that is not about producing energy, but basic research on nuclear reactions at low temperatures.
Of course, a podcast can only scratch the surface of such heavy topics, but if you want something entertaining apart from software development that is interesting, yet easy to consume on the treadmill, give these episodes a listen.
-
How to Create a Thumbnail for a File in Windows
Recently I had to create thumbnails for various file types and it took me some time to search the web for a solution that works and doesn’t require the discontinued Windows API Code Pack.
Daniel Peñalba‘s answer to a question titled “Extract thumbnail for any file in Windows” on StackOverflow works beautifully (tested on Windows 7 and 8.1): http://stackoverflow.com/questions/21751747/extract-thumbnail-for-any-file-in-windows .
I didn’t find it immediately because of the use of the word “Extract” instead of “Create”, so maybe I can give it some more Google juice with this blog post.
-
Emaroo 1.6.0 Released
Emaroo is a free utility for browsing most recently used (MRU) lists of various applications. Quickly open files, jump to their folder in Windows Explorer, copy their path - all with just a few keystrokes or mouse clicks.
Emaroo 1.6.0 adds support for Photoshop CC 2014 and fixes an issue with the MRU list of Notepad++.
You can download it now on www.roland-weigelt.de/emaroo.
For examples of how Emaroo can speed up working with files, take a look at the “Why Emaroo?” section of the blog post announcing version 1.4.0.
-
Looking Back at UX Lx 2014
The User Experience Lisbon (short: UX Lx) is a three-day conference taking place in Lisbon, Portugal (Lisbon’s abbreviation “Lx” is derived from the former Arabic name al-Lixbûnâ used in the early middle ages, by the way).
The conference consists of two days of hands-on workshops and a day of talks. Featuring internationally renowned speakers, the UX Lx draws attendees from all over the world. According to the organizers 40 countries were represented in this year’s UX Lx 2014 that took place from June 4 to June 6 and marked the third time I attended.
Day 0
The traditional welcome party on the evening before the first day is good way to meet other attendees. Because not all tickets sold are actually for all three days and some attendees attending the first day come to Lisbon in the morning, the party isn’t crowded. And with the very open atmosphere of the UX Lx in general, it doesn’t take much time to somehow get involved in a conversation.
Day 1
Workshop: Designing for Change
Christina Wodtke spoke about the psychology of change, why users resist it and how to introduce changes to a software and its feature set without steamrolling over the existing user base. In the hands-on part, groups worked on designing a new feature to a travel application. It is always interesting when you start working on a common goal with complete strangers, each of which brings a very different background to the table. For me, that’s a very important aspect of the UX Lx.
The first workshop uncovered one general problem of the UX Lx conference, the half-day format of the workshops. Year after year it seems that many speakers usually give full-day workshops at other occasions and strip them down to fit into three hours at UX Lx. At three of four workshops I attended, the speakers ran into time problems and noted something along the lines “usually this workshop is longer…”.
Lightning Talk: From Lo-fi to Hi-fi - A walk-through of prototypes
Péter Polgár presented various types of prototypes and did a solid job overall. The use of a zooming mind map presentation tool felt a bit gimmicky though and didn’t really help the talk.
Workshop: Experts Reviews for Experts
It’s always great to hear a speaker whose experience is measured in decades, not years or even months. Rolf Molich is one of these few. His workshop was well-prepared, perfectly timed and he even brought his own evaluation forms. Molich gave an introduction to “experts reviews”, where UI/UX experts (with enough actual experience in the field) review a user interface. He also presented studies that have shown that these experts reviews can deliver good results (i.e. can find serious usability issues) in comparison to usability tests and are very competitive in terms of manpower and time.
In various exercises we analyzed user interfaces of growing complexity and discussed and prioritized our findings in work groups.
Conference Dinner: Buffalo Grill
During my first visit I didn’t book any of the conference dinners, last year I found out that I missed a great opportunity to talk with other attendees. This year, I again booked all three of them.
The barbecued meat at the Buffalo Grill was really great. The restaurant itself turned out to be a bit loud because of the bare walls, though. And some attendees single-handedly raised the noise-level by being audible across the whole room, causing everybody else to raise their voice. Still, I had some very interesting conversations.
Day 2
Workshop: Collaborative Research
The workshop by Erika Hall mainly dealt with techniques for interviewing (potential) users and how to gather insight from the statements of the users. In the exercises we practiced this by interviewing each other, switching roles along the way.
Interesting how (in my opinion) I really totally sucked at conducting the interview compared to the others in my group, but at the same time how I was much better able to extract the core insights, dividing seemingly related but in fact orthogonal statements. A sign how different the backgrounds of the attendees were. Everybody I talked to during the conference was really smart, yet excelled at different abilities.
Lightning Talk: Fun, Confusion, Fear and Basketball
What a strange title – who, right in their mind, would give a talk such a strange title? Oh wait, it was me.
In my first session in English at an international conference I spoke about my hobby project of writing software for rear projection screens and LED advertising system. The “confusion and fear” part of the title alluded to the usability problems that I ran into while using the software in high-pressure situations in the arena – situations that were notably different from the calm atmosphere of testing the software at home.
My talk about stumbling blocks and lessons learned was well-received and it’s nice when people walk up to you even a day later and tell you how much they liked it.
The slides can be found here: http://www.slideshare.net/RWeigelt/fun-confusion-fear-and-basketball-ux-lx-2014
Workshop: Designing for Discovery with Faceted Navigation
This workshop with Jim Kalbach about faceted navigation started out really promising and I’m sure that the full-day version rocks. I really enjoyed the talk parts and the many examples, starting from early history (even though in the back in may head I knew that the timing was off). The half-day version turned out OK, but exercises had to be cut towards the end.
Conference Dinner: Populi
The restaurant on the second day was in downtown Lisbon; transportation to the Populi was provided via buses, the way back wasn’t a problem either with a Metro station in front of the restaurant. Also a bit loud, but again lots of interesting conversations.
Day 3
The third day of the UX Lx conference featured the following sessions:
Mike Monteiro: How Designers Destroyed the World
A passionate talk about the responsibility towards “the world” that designers have when they design a feature (that e.g. breaks the user’s trust), an advertising campaigns (cigarettes, anyone?) or something else that may do harm.
Kate Rutter: How Designers Can Build a new World
Designers and entrepreneurship – a well-delivered talk that didn’t really catch me, partly because I don’t envision myself to be part of the target audience for this talk.
Russ Unger: Things I've learned from leading UX Designers
Not exactly my area of interest, but very honest presentation. Slides are here: http://de.slideshare.net/runger/ux-lisbon-things-ive-learned-and-am-still-learning-from-leading-ux-designers.
Jason Grigsby: Adaptive Input
Great talk about the challenges of unifying user interfaces to be used by mouse or touch at the same time. The key sentence: Input matters more than screen size. The slides: https://speakerdeck.com/grigs/adaptive-input-uxlx.
Christina Wodtke: The Mechanics of Magic
Christina spoke about the power of games to create emotions, and at the same time warned about the dangers of gamification. The hunt for badges and a place on a leaderboard may initially provide some sort of incentive to use a system. In the end the metrics will either make people game the system – or no longer care. In both cases the original intrinsic motivation is finally killed off, with the end result being highly undesirable.
Bill DeRouchey: History of the Button
I really enjoy everything related to the history of computing in general, and looking back at the history of something as simple as a button is a really worthwhile topic. A talk that explains a (mechanical) button as an “abstraction of movement” definitely hits a certain vibe with me. An inexcusable lapse though was presenting the Mac in 1984 as the starting point of the button in user interfaces (or at least giving the impression on the slides). Not cool.
Jess McMullin: Citizen Experience Design and You!
Well-presented, but didn’t really work for me.
Margot Bloomstein: Content strategy for slow experiences
The talk started out a bit slow (how fitting) before it came to the point and suddenly it all made sense. Increasing the perceived performance of a system is one point. But there are actual use cases for creating deliberately slow experiences that people perceive as thorough and valuable, for example when buying specific equipment (cameras, outdoor clothing).
The slides: http://slideshare.net/mbloomstein/content-strategy-for-slow-experiences-at-uxlx
Steve Baty: (Re)framing - The first step towards innovative ideas
The three days finally took their toll and it seems my mind wandered off during that talk, right now I cannot remember what it was about. I only remember that when the talk was finished, I wondered whether the next talk could keep me awake. Little did I know.
Jared Spool: UX Strategy Means Business
My personal highlight of the day and a strong way to end the day. This was exactly the kind of session for broadening the personal horizon I am looking for when visiting the UX Lx conference.
Robert Sterry blogged about the session, the slides by Jared Spool are available as a PDF file.
Sunset Boat Cruise
Like last year, the weather didn’t like us. But also like last year, at least it stopped raining towards the end. And it was a lot of fun nevertheless.
Conference Dinner: Portugália
The weakest of the three restaurants; not just my personal opinion, but also of others I talked to. When a woman makes a remark about the not exactly huge portion size, you know something went wrong. And many of those who chose the chocolate mousse for dessert simply didn’t get it (no longer available, sorry).
The conversations at the table I sat at weren’t so much about UX, but more about topics ranging from the upcoming FIFA World Cup or Basketball in Germany and Lithuania up to the fall of the iron curtain and how it was experienced by people from different nations. I enjoyed it very much.
Final Thoughts
In a time of virtually endless content on the Internet, it becomes increasingly harder to justify a (physical) visit to a conference. In the case of the UX Lx, it’s not just about the pure content. It’s also about getting inspired (which is much harder viewing a video on a computer screen) and communicating with other attendees. The evening activities give you enough time for longer conversations that go beyond what is possible at the lunch table or during the breaks. And the openness of the attendees makes it really easy.
So will I attend next year? If time permits, yes.
