martin_ky

The Slovak land register was hacked in January 2025. Hackers uknown encrypted the database, asking for an undisclosed 7-figure amount as ransom.

The whole country's real estate market was paralyzed for about a month. It took couple of months to restore everything from backups and paper agenda and resume normal operation of the land register office.

It was the largest cyber attack in Slovakia's history. The authorities to this day haven't provided any information on who might be behind it. The investigation is still ongoing. Several government figures including the PM were however very eager to immediately point on Ukraine, without any sort of proof.

Agreed. The Qt framework, which is a cross-platform UI framework, does a decent job mimicking the native Win32 looks. Inside, the code is a giant mess. But on the outside, the API is very well thought out and easy to use.

Oh, how I hate when vendors bring "modern web" aesthetics to desktop utility programs. For example, Docker Desktop could go a long way in terms of usability if it just sticked to Win32 common controls - the kind of buttons, labels and list views that have been around since Windows 95. Maybe I wouldn't even have to wait 10 seconds for the main window to show up every time.

I'm not discussing Netflix's fiscal results. My comment is about their production quality, which I find to be low and their limited content selection. Obviously, that is my experience which I don't generalize to other people.

Yes, it's totally fine to be dissatisfied with a service and cancel subscription when you're no longer getting the value. I think that it's the rational thing to do.

I'm also finding that I'm getting far more value (both entertainment and educational) from YouTube than Netflix.

Lately, several months go by without me even touching Netflix. I'm at the stage, where I keep the subscription because of maybe one show in a year which I then watch in a week, when it's finally released.

My thinking exactly. Got Netflix couple of years ago because of the Witcher and since then I'm finding it hard to find anything watchable. I was going to say that they heavily favor quantity over quality. But not even that is true, since their selection is rather limited. The search result "we don't have X, but you might like A, B, C" which are usually the same and unrelated things over and over, appears way too often.

I'd say the reality is even more ironic - they collect so much data and reports, pretending this is to help to improve the user experience, but in the end it makes the experience so much worse.

It seems to be a pattern with (not just) Microsoft products to hang the UI while waiting for some remote API, usually talking to the home base. Happens a lot to me with Office desktop apps - they freeze sometimes for a good second or so while starting and more surprisingly also when closing. One time it bothered me so much, that I recorded an ETW and unsurprisingly the time during the hang was spent waiting for some http request. I noticed that often the online version of these apps (namely Outlook) are more responsive than the desktop counterparts.

Edit: My experience with Excel - https://twitter.com/martin_ky/status/983019737729916930?s=20

I’m only familiar with Flash as a user, not as developer. I’m curious, what did Flash have, that you can’t readily do with JS and Canvas? Be as broad or specific as you like.

That might be the original motivation, but post-7 Windows UI is anything but unified or consistent. New and legacy UI toolkits are mixed in the system shell itself. There are still parts of the good old Control Panel that haven’t been ported to the new “immersive settings” app. Already in a clean Win 10 installation, you can spot at least 3 different styles of context menu, depending on which part of the desktop you right-click.

Google’s UI has been cycling between bad and worse. That goes across the board - websites, Android, apps, everything.

I have never come across a Google product and thought “this is a well designed and clear to use program”. Except perhaps Google Search and Gmail of old - between circa 2005-2008.

See where it goes?

To a state where users need a (another) datacenter to access/view/use even trivial apps with “reasonable” responsiveness. There are services already being offered to this end [1].

[1] https://mightyapp.com/

Electron is not exactly an epitome of a resource efficient framework either. If I was to compare efficiency, I’d choose a native baseline, such as the X window system or WinAPI. Granted, these APIs are low level and not as rich in features. Typically, the user calls some sort of “mark as dirty” function to mark a region of the window to be updated on the next refresh cycle, thus not wasting resources on portions of the screen that were not touched.

I like the concept of decoupling storage from the editor app. I wish more SAAS providers recognized this as an important product feature. It would allow deployment of hosted services in much wider range of scenarios, where privacy and data ownership is a big concern.

In addition to what has been said in this thread about office culture, politics, internal processes, etc. I believe a big factor in reducing work-related stress in any job, is actually being competent at your job.

What I mean is, work in a domain you know something about, with tools and technologies you know well. Be comfortable with your skills and know they are on par with the task you've been given (and also know when they are not). Don't put more on your plate than you can take.

Of course, being too comfortable can result in stagnation. Sometimes, we need to push ourselves or be pushed in order to learn and grow. Let your superiors know when a task is outside your comfort zone. A good mentor will try to push you, but also let you fail gracefully.

It’s 2018 and I still see people walking around with Windows laptop lids open because they presumably have no confidence in Windows’ ability to sensibly preserve state after closing the lid.

At my workplace it's about 60:40 Windows to Mac user ratio. Regardless of the machine, nobody closes the lid when moving in the office between desks and meeting rooms. So, I'd say it's probably not that.

Right. There's nothing revolutionary here, that's for sure.

I think, it could have been Java (or the JVM at least) in place of WebAssembly in browsers already a long time ago, were it a more open standard.

I think, this goes way beyond just companies preferring to hire cheaper developers and beyond software engineering as such. There is a larger, universal force at play here. Examples of poorly designed, engineered and built things are everywhere in the world. It is seemingly cheaper to do it this way. But what may be saved upfront on production quality, is usually spent many times over on usage, maintenance and subsequent rebuilding, making the total cost higher.

For example, a road built with cheaper materials will break and need to be patched more often. A poorly engineered application will be slower, consume more CPU power, more data bandwidth and require more storage space, will be buggier and waste more users' time.

With only a very basic understanding of economic theory, I would imagine that market forces at scale would optimize these inefficiencies and ultimately work to reduce total costs. Perhaps this unconscious, natural process would even work, were we not consciously optimizing against it on the wrong variables, such as the next quarter's profits.

Qt on WebAssembly is analogous to the plugins of yore like Flash and Java applets. WebAssembly is kind of like a new plugin container for native code.

No it’s not. With WebAssembly, it is a matter of trust in your browser vendor and its ability to properly sandbox WASM/JS content. With plugins, you basically gave up full control of your machine also to whichever plugin vendor. The number of trusted relationships is different - it’s fewer with builtin WebAssembly. That is a noteworthy distinction, I think.

With Qt you get a lot of conveniences and built-in magic, but I'd say at that point it's not really regular C++.

This is a common misconception of beginner Qt users or people who just looked at Qt superficially and decided not to use it, because it's not "regular C++".

You use Qt with 100% pure C++. Qt itself is written in 100% pure C++. The part that confuses people is the metaobject compiler (or MOC). This is a simple code generator tool that provides additional features like runtime type information and reflection. It does not modify your source code, only generates some additiona, 100% legal C++. Granted, this requires an extra build step before invoking the C++ compiler. But Qt's build system handles this automatically, and it's not really difficult to integrate into any other build system.

Starting with Qt 5, you don't even need to invoke the MOC compiler, because in many cases, the features provided with generated code were replaced by new C++11 functionality.

If/when C++ gets proper metaclasses and programmable compile-time code generation, there will be no more need for MOC, because all of its functions can then run in a single compilation step.

There's a great blog post debunking the myths about the QT metaobject compiler - https://woboq.com/blog/moc-myths.html

When I do any non-trivial UI in the web stack, I can feel I am in continuous workaround territory. I'm trying to bend something ill-suited to my will. I don't get that feeling with QML.

That has been my experience as well.

I think the web dev crowd advocating HTML/CSS originates in a) limited knowledge beyond the web tech field, and/or b) thinking that web is the state-of-the-art of computing.

The trouble with modern web is, that it was not so much designed as it evolved. But evolution in general is doggone slow and produces mistakes and mutations. I think the evolution of the web platform is still in a very early phase.

Yes, this. The HTML language and DOM model is inadequate for implementing interactive user interfaces. It's a text document markup language after all. QML has its own DOM structure and a library of primitive visual elements called QtQuick. QML and HTML are very similar in fact. The main difference though is, that the QML language and its library of primitive elements was designed from the ground up as the language for building interactive, fluid, animated user interfaces.

Consider something trivial as centering a user control within a parent control. Good luck getting it right with HTML and CSS in a way that works across browsers. With QML you just write:

    Rectangle {
        anchors.centerIn: parent
    }

There is some discussion on this from last year - https://news.ycombinator.com/item?id=14894937

This release of Qt for WebAssembly is the first officially released prototype of this technology. Qt comes from the native desktop world where it relies and builds on top of the whole rich world of native OS APIs. There's nowhere near that API support on the web platform at the moment. Also Qt might not be using the full capabilities of the web platform in this first release. Naturally, the first results are crude. But Qt has a great platform abstraction mechanism, so I'm sure it will only improve over time, either making better use of existing web APIs or support new ones as they become available.

Also it is worth to point out, that there are really 2 GUI toolkits in Qt:

Qt Widgets - the more classical, desktop UI paradigm. Yes, this renders everything into a bitmap and therefore translates better to the Canvas model on the web.

QML / Qt Quick - more DOM like, declarative UI with modern animation, scripting and data binding features. This maps better to the HTML DOM model. In theory at least, however, the similarity is only superficial. Under the hood, the QML visual elements are rendered with WebGL.

I think, it's time to start to perceive content publishing and application authoring as two distinct disciplines. The problems you describe arise from mixing them freely and without much thought.

Oof - the point of WebAssembly is not to stick your entire UI in Canvas.

Well, the way your operating system works with UI is that it gives each application one or more pixelbuffers, where the apps draw their pixels however they want (2D drawing API, 3D gpu-accelerated API, a widget toolkit, a HTML DOM renderer, etc). At the end of the day, you could say that any application interface is just a metaphorical Canvas - a memory buffer that is composited with other apps and eventually copied over to the screen buffer by the OS. Web browsers are becoming more and more like operating systems in this regard. Is it a good thing? That would be a good discussion.

This really rubs me the wrong way, it's a major step backwards for accessibility and user control.

Accessibility has really nothing to do with Canvas, when you look at it simply as the API for drawing pixels. Accessibility is a way of providing the OS (or in this case the Browser, which in turn provides this info to the OS) with a parallel stream of information that describes the scene (text content, navigation controls, etc.) The OS then makes this info available to accessibility tools such as screen readers or data scrapers. Accessibility is a completely orthogonal concept and should not be tied to rendering. For example, you are probably not going to need to support a Braille screen reader in a 3D zombie shooter game, yet you can use Canvas 3D to render it. After all, accessibility in games is a different topic entirely. What you want, is an accessibility API that you can use or ignore, depending on your use case. If you don't want to deal with an accessibility API manually, use a widget toolkit that does it for you. Coincidentally, the Qt Widgets library has accessibility features implemented when the underlying platform provides an accessibility API.

Sometimes APIs on the web are difficult because they're poorly designed.

I agree that most of the issues described in the parent post is a direct consequence of bad or non-existent API. After all, a runtime is nothing without powerful APIs.

I am increasingly suspecting that native developers just don't understand what the web is trying to do. The web is different from native because it's solving problems that native developers don't even realize they have.

In all honesty, I believe if web developers took some lessons from the native world, they would realize that many of the problems of the web platform arise from its poor design and application of wrong paradigms on the wrong problems. Take the whole web UI thing for example. Even most trivial things, like trying to center something on the screen in HTML+CSS is a horrendously difficult chore with many possible and no right way of doing it. The whole idea, that a simple markup language that was designed for publishing and linking of text documents, can be used as the basis of a general-purpose application platform, is ridiculous.

Electron is just outsourcing cross platform development to the Chromium project.

... and ultimately to the consumer, who pays for higher spec'd hardware and more electricity.

I think you hit the nail here with "poaching someone's turf" and the "tribalism" inside a company. I didn't mean to say that leadership considers engineers stupid. They hire them and trust them with solving complex technical problems. It just bothers me, they would often rather take a vague, generic management advice from a third party, who could not care less, over well intentioned, well reasoned, concrete advice, backed by concrete evidence from an engineer (or just do not act at all). This is just my colorful imagination, but I could almost 'hear' some managers thinking while dismissing an idea without giving reason: "I am supposed to manage you, no way you are going to tell me how to do my job". I've seen such behavior and I have no other explanation for it other than ego, office politics and 'cover my ass strategy'. This creates toxic environments and not just for the people working there. Productivity, quality and I'm 100% convinced that ultimately revenue and the ability to compete suffers from this as well.

I'm sure this article resonated with many engineers, not just from the game industry. What resonated with me the most, was the part about hiring a consultant, only to tell management what their employees have been telling them all along (for a ridiculous hourly rate of course). The simplified executive line of reasoning, why to rather trust an external entity over their own people, goes usually along these lines: "We do not take advice from our employees. We hired them for grunt work and we only expect them to follow orders. What could they possibly know that could benefit our high-level decision making. Afterall we pay them so little".

I consider the case, which the author describes, where the consultant actually talks to engineers, a happy day scenario. I was witness to a fast growing startup hiring a well known global consulting firm to help them set up company structure and processes. The startup was unable to do this on its own because of lack of leadership and unwillingness of the owners to empower their own people. The consulting firm sent over a couple of their junior consultants who consulted their 3-ring binder of best practices for the nearest matching industry category and gave their recommendations, which were followed quite strictly by a newly hired junior management. All without talking to a single engineer.

More often than not, employees are considered a necessary means to an end and treated as such, with the least amount of reward and care for which they are willing to work. Their sense of professional honor, responsibility and guilt is often exploited in an attempt to achieve higher output. Does the company's products or services suffer because of this? Of course, but nobody at the top cares as long as there is a metric that tells a good story. And when not, the lowest ranks are the first to be pruned and restructured.

Agreed on all points. The C++ Standard Library should not try to become the next .Net Framework.

Libraries such as 2D graphics can be created any day by the worldwide C++ user community. Only the isocpp.org can change and improve the language itself and that should be their main focus.

You are technically not wrong, of course, but if the attack vector got already to running Makefiles on your system, you should probably focus your effort to tighten security elsewhere.