Nikola Plejić: blog

Tracking Butterflies

2024-04-23T09:45:00+02:00

Link: Technical Perspective: Creating the Internet of Biological and Bio-Inspired Things – Communications of the ACM (full paper)

I love the CACM’s “Technical Perspective” series where they provide an accompanying (technical) summary of a larger research paper! More than once it made me dive deeper into papers that I would’ve skipped otherwise — like this research wholesome enough to warrant a break from the all-encompassing cynicism of 2024. I’m unsure about the animal welfare aspects of this, but it seems non-invasive and useful so I’m willing to give it the benefit of the doubt.

Humanity has tracked migratory patterns of different animals for a while, but these were limited to larger species that make it easy to attach the necessary devices. I recently heard Felix Stalder talk about the project “Infrastructure of a Migratory Bird” based on data collected by such research, and it’s a wonderful (and beautiful) way to understand what’s involved in these undertakings (spoiler: it’s a lot).

In this paper, the authors build infrastructure to track the migration of monarch butterflies. Butterflies are tiny, and attaching a full-blown tracking device to a minuscule living thing that travels up to 4000 kilometers sounds impossible… yet here we are. It’s utterly fascinating to read what goes into this: it combines seemingly contradictory features like low-power computing, offline-first (with 16 kB of memory!), and machine learning to provide insight into the Earth’s ecology.

On User Interfaces On the Web & Beyond

2024-04-16T09:45:00+02:00

Link: The Decline of Usability: Revisited | datagubbe.se

This has to be an “old man yells at cloud” situation if there ever was one, but as someone who remembers at least some of the systems outlined in the article, it’s hard to disagree with its conclusions. The web is the platform that’s most familiar to me and resonates the most, but the text repeatedly demonstrates things aren’t great on other platforms either. (Although, with the Electrons and the likes, it’s not even clear where the web ends and “other platforms” begin.)

During the peak of Bootstrap, people complained that all websites and webapps are starting to look the same. I am demonstrably not a designer, and I’m sure there are good arguments to be made in favor of some diversity being desireable. That said, I always thought that “websites looking the same” isn’t the most expensive price we could pay for familiarity and consistency of our interfaces. We’ve since long abandoned any attempts to achieve that — to great success.

Browsers, of course, have decent defaults for dealing with web sites (see, e.g., danluu.com), although it would be difficult to argue that this feels remotely “familiar” in 2024. There are no good defaults for web apps — HTML was never intended to be a UI toolkit, so at best, we’re playing catch-up. I was hoping that the likes of React and Web Components might result in a couple of well-adopted, powerful UI toolkits for the browser, but it’s predominantly used as a way to churn out gazillions of ad-hoc, low-quality, non-standardised components.

(To be fair, there are good UI toolkits built on top of modern web frameworks out there. I’ve worked with a few: they’re mostly commercial, but that’s fair game. None of them could be described as “well-adopted”, though.)

The unexplainable need to replicate mobile & e-commerce UIs to software in general sounds like a plausible explanation for this mess. My unproveable side-hypothesis is that there’s another component at play: the incredible ease of updating modern software. Early on, distributing software was hard. Distributing updates meant having users savvy enough to figure out an update had been released, and determined enough to actually install it. You really had to think long and hard about your UI choices, and unless you’ve had very good reasons not to, you chose consistency. Today? Release any random crap, then measure and/or listen for feedback. No need for serious thought — it’s not like you’re burning this on a CD.

Current Affairs on Ye

2024-03-29T10:23:00+01:00

Link: Ye and the Problem of Fascist Art ❧ Current Affairs

Any fan of “extreme” music comes to terms with the questions posed by this article on a regular basis. This is certainly not the first event of its kind in the mainstream, but it might be the most blatantly direct specimen: it’s almost cathartic to see people wrapping their minds around it in real-time. The analysis here is convincing, if a bit obvious: becoming a billionaire seems to have an uncanny tendency to make you stare into the abyss of fascism a tad too long.

I do like the attempt at adding nuance to the idea of the “death of the author”, where the question becomes whether the line between the artwork & the author has been completely blurred to the point of the author using their art as a vessel to — purposefully or not — disseminate their less than stellar life choices. I’m unsure how much of this is just a desperate attempt to reconcile the cognitive dissonance, but it’s a compelling framework to consider.

It’s not too surprising that a Current Affairs article ends up — very correctly — talking about “blame misdirection” and systemic issues, and I find it very hard to argue with the conclusion. The single remains in Billboard’s Top 10, though. Ye’s art might not be his own anymore, but it’s still out there, legitimizing the bile and mobilizing the crowds. So what should we do? Some of those beats are sick. Should the critics give it four stars and dive head-first into a marxist critique in sentence one? I think they certainly should do the latter, but it probably won’t do wonders for their reach.

Personally, the obvious case of Ye aside, I think there’s too much music out there to waste time on assholes. I won’t go actively digging for dirt in artists’ histories, but I’m trying to be aware of the context — I’ll skim through the liner notes, I’ll look at the iconography, I’ll read an interview. I’m more than willing to give the benefit of the doubt to people who clearly distance themselves from their mistakes. Otherwise, heeding the good advice of Jon Stewart: if I smell something, I’ll say something — and actively support the deserving non-assholes.

Antirez on LLMs

2024-03-27T19:35:00+01:00

Link: LLMs and Programming in the first days of 2024

Salvatore Sanfilippo is certainly a programmer I look up to: I’ve appreciated both his software and his writing for a long time. This article that’s been in my reading queue for a while is a sober take on the topic, and I found it insightful to see how he incorporates LLMs into his workflow.

What he calls “junk knowledge” — obscure APIs, convoluted protocols — seems like a good use case for these tools. I’ve tried to steer my usage in this direction, too: I’ve recently had to work with AWS a fair amount, and ChatGPT ended up being genuinely useful. While the “CloudWatch Logs Insights query language” is handy, and I’m sure someone had a lot of fun implementing it, I’ll gladly opt out of learning even more syntax I’ll rarely use.

All of that said, it’s important to continuously remind ourselves of the cost of these tools — in watts of power, in [insert unit]s of privacy — particularly by our thought leaders. I haven’t seen much of that in this article, but Simon Willison’s recent writing on “ad-hoc sidequests” does a good job in its closing words. I’ve been enjoying his other writing on this topic as well.

2023: A Year In Review

2023-12-26T12:45:00+01:00

Previously (2019), previously (2020), previously (2022).

Academics

I’m writing this during a (lengthy) layover in Salt Lake City on the way back from my visit to the US. (Mental note: do visit SLC one day! It looks pretty.) This one included a much anticipated graduation ceremony: after slightly more than two years, I’ve finally graduated from the OMSCS program at Georgia Tech!

As a kid, I dreamed about going to MIT: I still have no idea where I had first heard about the school but studying computer science at a prestigious US university seemed like the bee’s knees. Going to Boston, of course, wasn’t likely to happen: I was no planetary-grade wunderkind, and my post-war working-class parents had too few internal organs to sell. All this made it extra surreal to walk around the Georgia Tech campus as a fresh graduate.

People tend to ask why I’ve decided to do this, and the answer is… because I could? I certainly didn’t have to: it’s not likely this diploma will have any immediate impact on my career. It was a fun, decent challenge: I’ve learned a lot, and it feels good to have a formal verification of my skills.

Travel

The big trip of the year was our summer vacation in Scotland. We were insanely lucky, and had the best weather one could hope for — to the extent that it doesn’t really feel like we’ve properly experienced Scotland. We saw Edinburgh, parts of Skye, and walked the very final stretch of the West Highland Way. It’s a beautiful country: I have photos but they can’t do it justice.

Otherwise, work led me to London a few times, Sara and I spent some time on the beautiful Croatian island of Vis, and took a short weekend trip to my place of birth, Sarajevo. The year wrapped up with a visit to Atlanta (see above) followed by an almost traditional end-of-the-year trip to Phoenix.

Books

Fiction-wise, I’ve read all five books in Abir Mukherjee’s “Wyndham & Banerjee” series. It’s a very well-written set of detective stories set in early 20th-century India with a lot of references to its colonial past. In a vaguely similar vein, I’ve read Holly Watt’s “To The Lions” and “The Dead Line” which were a bit more taxing but very good.

I dove into Ruth Ozaki’s “The Book of Form and Emptiness” after a review in The Guardian, and thought the review did it justice — it was captivating, and any air of pretentiousness disappeared after a few pages.

As far as biographies & memoirs go, Chelsea Manning’s “README.txt” was an important but painful read. Ananyo Bhattacharya’s biography of John von Neumann, “The Man from the Future”, was brilliant: it’s quite a feat to attempt to capture the life of someone who had such an impact on the 20th century, and I’d say this was a success.

On the more technical side, William Kent’s “Data and Reality” is often mentioned as a classic of our field. Its examples are expectedly outdated, which does make it overly difficult to read but it’s extremely insightful: this is the book you want your domain experts to read in order to understand what the hell’s happening in your head when you’re writing software.

Finally, I’ve read “Facts and Fallacies of Software Engineering” by Robert L. Glass. It was undoubtedly good and important but the quantitative aspects of it seemed less than convincing. The referencing is very good, so I guess it’s up to me to follow up and convince myself.

Music

The event of the year was the departure of Peter Brötzmann, the great German sax player. I still remember hearing “Machine Gun” for the first time in high school, and being — somewhat literally — blown away: I had no idea you were allowed to do that on a record, and I’m not exaggerating when I say it had changed my view of music.

I’ve had the privilege of seeing Brötzmann play live in Zagreb several times, most recently with Heather Leigh, and his level of dedication to the music was always inspiring. This posthumously published interview of his (in German) got me very emotional — what a brilliant human being.

Concert-wise, things seem to be picking up pace, yet I’ve been lazier than I should’ve been. The crown jewel was Lean Left’s residency in Cafe Oto which wonderfully coincided with a work visit — and what a residency it was.

The list of albums is a bit shorter this year but it’s not due to lack of music — it’s definitely me:

Algiers: Shook
Ambrose Akinmusire: Beauty is Enough
A.M.E.N.: The Book of Lies - Liber I
ANOHNI: My Back Was A Bridge For You To Cross
Arooj Aftab, Vijay Iyer, Shahzad Ismaily: Love in Exile
Cattle Decapitation: Terrasite
Dawn Ray’d: To Know the Light
Feist: Multitudes
Fever Ray: Radical Romantics
Forest Swords: Bolted
John Zorn: New Masada Quartet, Vol. 2
Liturgy: 93696
Oozing Wound: We Cater To Cowards
Outer Heaven: Infinite Psychic Depths
Satoko Fujii & Otomo Yoshihide: Perpetual Motion
The Tallest Man on Earth: Henry St.
They Grieve: To Which I Bore Witness
Wednesday: Rat Saw God
Yves Tumor: Praise A Lord Who Chews But Which Does Not Consume; (Or Simply: Hot Between Worlds)

Politics

Locally, the green-left party in Zagreb is still making strides. It’s difficult to address 20+ years of neglect and active destruction in three years’ time, and it’s even more difficult to properly communicate this to the public. Next year is super-electoral: it’s likely we’ll have all four types of elections (parliamentary, EU, presidential, and local) in a one-year period, and it’ll be interesting to see how it unfolds.

I’ve been significantly less active due to my academic endeavors, and I’m looking forward to getting back into it next year.

Misc.

I’ve spent some more time recovering from my shoulder surgery, and recently started feeling like I finally have a decent range of motion. It’s been long and painful but the shoulder is stable, and that’s all I could ask for.

I’ve never been much of a gamer but I bought a Steam Deck as a graduation present to myself. I’ve been enjoying it a lot: if someone had told me 10 years ago that we’d have a handheld device running AAA games running Linux, I’d suggest them be institutionalized — but here we are. Kudos to the folks at Valve.

I’ve continued helping my good friend IMS with his website for The Program Audio Series. There were no substantial updates to the website itself but he did release a couple of amazing episodes, and anyone reading this should check them out.

All else has been stable, and I wouldn’t mind it staying that way.

Plans for 2024

I’ve started toying with a user-land implementation of TCP/IP, both as a way of understanding the protocols a bit better, and as a foundation for a more ambitious project I have in mind. Motivation and inspiration are elusive beasts but I’d be happy to make any kind of substantial progress towards finishing it.

Otherwise:

keep up with my workout schedule, as it’s certainly doing me good;
(finally) visit Rome with Sara;
be a good and supportive partner;
live to see 2025.

Thoughts on Large Language Models

2023-03-11T13:10:00+01:00

Epistemic status: I have no idea what I’m doing.

We’ve been discussing so-called “Large Language Models” (LLMs) during our past few gatherings in the local hackerspace. None of us are ML experts, but we’re all experienced professionals (mostly in software engineering of various kinds), and have diverse enough backgrounds for it to be interesting.

I wanted to jot some of the resulting thoughts down for posterity. I have no way of attributing these to any particular person as the discussions were… lively, but all of it has gone through yours truly thus it’s certainly plagued by my own misunderstanding and misconstruction. Nonetheless, it might be interesting to revisit them in a few years’ time.

The Ugly

The interesting part is that none of us seemed to be worried about the short- and medium-term prospects of AGI (artificial general intelligence). Personally, this is equal parts due to my scepticism on “strong” AGI in general, and a lack of belief that society will live long enough to achieve AGI. In addition, I always feel uneasy discussing AGI as I find it to be an ill-defined topic: we’re not really sure what “intelligence” and “consciousness” are when it comes to humans, and attributing such properties to computer programs seems odd.

There also seems to be a consensus that the LLMs we currently have are dangerous enough, and that the “AGI scaremongers” aren’t doing much about it. I always thought it’s interesting how the loudest and most paranoid folks sit on boards of companies and “think-tanks” most likely to end up actually producing AGI. My dudes¹: if you’re so freaked out by the prospects of what you’re doing, simply… stop?

The argument here seems to be “if we don’t do it, someone else will”. This one’s kinda hard to refute, but here’s where I like to remind myself that the acronym for “mutually assured destruction” is “MAD”, and I can’t imagine that to be a coincidence. There’s some prior art here, and it’s not necessarily working in our favour.

The most immediate thing everyone’s worried about is the ability to generate a huge amount of very convincing text that has little to do with reality… a.k.a. complete and utter bullshit. Sure, OpenAI has these huge filtering layers that try to prevent the most disgusting of the options. These are… not perfect, and they mostly deal with the gory aspects of humanity. When it’s not trying to convince you that your obvious attempts at racial profiling are morally wrong, it’s still full of crap.

As a very benign example, my own attempts at using ChatGPT to clarify certain aspects of my quantum computing class weren’t great. I tried to see if it’d be able to argue whether a Toffoli gate is a valid oracle for the Deutsch-Jozsa algorithm²:

First, it claimed it’s not a valid oracle because it maps two input qubits to one output qubit rather than n qubits to one output qubit, which is silly as n=2 is a perfectly valid scenario.

As a follow-up, I asked whether it’s a valid oracle in case where I only have two qubits as inputs, and it claimed it was.

I wasn’t convinced, though: with the target qubit set to |1> as in the Deutsch-Jozsa circuit, the Toffoli gate doesn’t seem to represent a balanced or constant function, which is a requirement for the oracle…

That truth table simply isn’t correct. At this point, I decided there really is no alternative to shutting up and calculating.

The Bad

Setting aside deeper existential concerns, there’s a different set of more prosaic issues that pop up.

It’s impossible to reproduce ChatGPT. The resources required for running LLMs are immense, and the resources needed to train them more-so — assuming you’re able to get your hands on the training corpus. Even if this ends up being the most benign and useful tool in the history of mankind, we’ll end up in the same place we always seem to do — with the means of production concentrated in the hands of the rich few. Sounds vaguely familiar.

Another issue is the “lack of traceability”. LLMs regurgitate things found in their corpus, which isn’t completely unreasonable, as that’s what they’re designed to do (ish?). However, there seems to be no way of programming these networks to actually attribute this regurgitation to its sources. Fighting bullshit is far simpler if the bullshitter quotes their sources (which, I guess, is why they rarely do), and avoiding plagiarism is far easier if you provide proper references. The level of granularity of LLMs probably makes this extremely difficult, and that’s not great.

The (Possibly?) Good

Now the good part: there seems to be some merit to it all. As a writing dilettante, I found the intra-textual stylistic coherence to be one of the more interesting parts of both GPT-3 and ChatGPT. Limiting my unsubstantiated claims exclusively to the English language, I feel like text generated by these models is more stylistically uniform than what ends up being produced by most non-professional writers.

I can imagine these systems being used by domain experts to write large amounts of text: prompt ChatGPT, sift through the bullshit, counter-prompt a few corrections & refinements, and finally edit the text to remove factual errors. It might not save any time compared to writing from scratch, but the end result might be better (for certain definitions of “better”). Finally, analyzing the resulting text could be a good exercise, the end goal being to become a better writer sans GPT³.

The conversational aspect of these models shouldn’t be underestimated either. Us hacker folks have spent most of our lives “prompt engineering” our machines in different ways — the idiosyncrasies of these systems are so ingrained into our brains we simply fail to imagine someone having trouble interacting with them. These failures happen regularly, though, and interacting with the machine in natural language is very attractive. Instead of adding quotes or minus signs or “site:reddit.com” to your search query, you can ask the machine to refine its output in your spoken language of choice.

That is powerful, and that is appealing. We need to make sure people understand there’s still a machine behind the output, together with all implications of this fact. I’m not sure whether we’re doing a very good job at the moment, and there be dragons. A good, approachable paper on this topic well-worth a read is M. Shanahan’s “Talking About Large Language Models”.

On a bit more science fiction-y note, there’s the very interesting question of what these models really are. People managed to train something GPT-like to play Othello, and the model seems to have inferred certain properties of the game⁴. Is this pure statistical symbol manipulation? Is it something more? Is there a difference? It’s fascinating to think about, and it’ll be fun to see if it produces some good science and/or philosophy.

I’m trying to wrap this up on a positive note, although the obvious position is defeatist. There’s many, many more things to consider here, yet we keep on keeping on without proper evaluation. I’m hoping we’ll be seeing much more good science and philosophy than well-written misinformation and terawatts of electricity flushed down the toilet, but this century doesn’t give too much material to cling to. Here’s to being alive and well enough to see the outcome.

Interestingly enough, it’s always dudes, isn’t it?

This is just another example where it’s almost critical for the user of the LLM to be a domain expert when using it in a research capacity. I had no illusions of the results being infallible so I triple-checked, but I might as well have taken it at face value.

Of course, you can totally do that without LLMs — by reading and analyzing text written by good writers. However, within highly specialized niches, it might not be obvious who these good writers are.

⁴

This is a preprint, and I’m not sure whether it’s been verified or reproduced — even if it has, I wouldn’t really be able to tell.

2022: A Year In Review

2022-12-23T16:55:00+01:00

Previously (2019), previously (2020).

2021

Since I skipped the review of the eventful 2021, here's an attempt at a summary in place of an intro:

Trying to bounce back after the mess that was 2020 was a decent challenge on its own, topped with illness in my immediate family (now under control, thanks to the marvels of modern medicine), getting vaccinated against COVID, and receiving the Christmas gift of COVID for both Sara & myself (tough, but with no serious consequences).

On the upside, I managed to squeeze in a couple of trips in & around Croatia, and even abroad. It was also the year I started my graduate studies at Georgia Tech’s OMSCS program, and the year the green-left coalition won the mayoral mandate and formed the majority in the city council of Zagreb.

Things in 2022 were mostly natural follow-ups to these… So here we go:

Academics

As planned, I started Georgia Tech’s Online MSc in Computer Science (“OMSCS”) in Fall of 2021. As my bachelor’s was delivered online, too, there were no big shocks regarding the format & expectations. The experience of OMSCS just reaffirmed my already positive views on formal education, especially in a distributed (distance learning) setting.

While I think anyone outside the United States would have to be very hard-pressed to describe an 8000+ dollar degree as "affordable", it's commendable how Georgia Tech managed to further decrease the costs of tuition during my studies. For the benefit of everyone outside of North America, I can only hope this trend will continue.

All classes I took so far were outstanding, but I’d have to point out the Operating Systems (both the introductory and the advanced), and the Computer Architecture classes as the outliers. They helped structure plenty of things I’ve previously glanced over or heard of, and augment it with a ton of context and depth.

In the meantime, Georgia Tech added a Quantum Computing class to OMSCS’ offerings, and I’m very much looking forward to taking it next semester. If all goes well, Fall of 2023 should be my last semester before graduating.

Work

After almost six years, I felt like I needed a change of pace career-wise. I left tvbeat and joined Minimum, a carbon accounting & management start-up, as a software engineer. As well as an opportunity to work on something I deeply care about, this also gave me the chance to — again! — work with one of my dearest and bestest of friends, Boni. It was also a great reason to seriously dive back into Python after a long while.

It would be difficult to overstate how much I've learned during my tenure at tvbeat, and how privileged I felt to be one of the few people to get paid to write Rust all the way back in 2018.

Travel

I spent late 2021 and early 2022 in Phoenix, a place I liked significantly more during winter than during summer.

During the rest of the year, I roamed around the UK a bit to visit my new colleagues in London, in addition to going up north for a short trip to the beautiful city of York. After a long time, I visited Budapest again. After three years, I visited my not-quite-birthplace, Vareš. Also: Rovinj, Gorski Kotar, Plitvice.

Books

There's this treasure of a website for Croatian readers called "e-lektire", providing ebook versions of a huge chunk of assigned reading for Literature classes in elementary and high schools. Its unsurprising focus is on Croatian literature, but there's a fair deal of European classics available as well: certainly enough to keep one busy for a while.

Perusing it, I read two books I skipped as a student: Dostoevsky's "Crime and Punishment", and Tolstoy's "Anna Karenina". Sadly, both Croatian translations available through the website were ancient — one of them from 1916! Consequently, the language and style was very hermetic and archaic for the modern reader, but not prohibitively so.

Making a value judgement on two seminal novels would be too pretentious even for a very personal text like this one, so let's just say I'm glad I finally faced my omissions. As a matter of happenstance, a modern translation of Crime and Punishment was published in 2022... I might treat myself to a re-read!

On a less pretentious note, earlier in the year, I spent some time hanging out with Andrea Camilleri's commissario Montalbano, a remarkable series of crime novels set in Sicily. My Italian is nowhere near the level required to read these, so I relied on Croatian translations here, too: this time the translation felt extraordinarily successful, almost to the point of absence.

Non-fiction-wise:

Four Thousand Weeks by Oliver Burkeman: a funny, important, brilliant investigation of humanity's relationship with time;
Stolen Focus by Johann Hari: an unexpectedly broad and nuanced text on our (lack of) ability to focus in modern times;
An Event, Perhaps by Peter Salmon: a biography of Jacques Derrida which I found worked much better as a nose-dive into his philosophy than as a biography.

Music

Not a lot of concerts this year for me. Slight COVID paranoia combined with post-lockdown laziness did its thing, and I found it very tricky to get back into it. A few that particularly stood out were:

75 Dollar Bill @ Močvara, Zagreb;
Anne Gillis & XT (Paul Abbott and Seymour Wright) @ Cafe Oto, London;
Senyawa @ Močvara, Zagreb.

As far as recorded music is concerned, I'll continue the tradition of listing albums I thought were particularly great in 2022 with Bandcamp / indie links where available:

I also went down the rabbit hole of Albert Ayler’s music, encouraged by the wonderful remasters released on the important ezz-thetics series by Hat Hut.

Politics

As mentioned, the Croatian green-left party Možemo! and their local partner Zagreb je NAŠ!, both featuring yours truly as a member, won the local election in Zagreb in 2021. Managing a big city like Zagreb would be tricky in any case, but after 20+ years of corrupt government, it proved to be even more challenging than expected.

I've carried on coordinating the parties' IT working group together with Dražen, and a few of us were trying to make sense of the city's digital infrastructure by volunteering in one of the mayor's working groups. After more than a year doing so, I feel significantly more informed on the public procurement legislature of Croatia, but terribly overwhelmed by the scale & velocity of change required for tangible progress.

That said, I met quite a few smart people working in the city administration, and found parts of the infrastructure to be in much better shape than I could ever imagine.

Health

Health-wise, I finally had to face an issue I’ve been fighting since elementary school: my notoriously unstable shoulder joint. Early in the year, I suffered another luxation. I stopped counting somewhere around dislocation #30, and I took this as a sign to finally go ahead with Bankart repair surgery.

I was in good hands in Zagreb’s Traumatology Clinic: the surgery itself was as uneventful as one could hope it’d be. The recovery was… long and painful. My range of motion was non-existent for the better part of the month post-op, and the pain during the first week was intense. Certain aspects of physical therapy were mentally draining: I felt prepared for physical pain (I wasn’t), but the stress of having to go through shoulder movements which would previously imply instant dislocation — that was on an entirely different level.

Luckily, I had Sara by my side, a good therapist, and visible, if slow, progress on a weekly basis. All of that helped keep my spirits up, and here we are. My range of motion still isn’t 100% there — it’s unclear if it’ll ever be — but the pain is gone, the shoulder feels stable, and I can do everything I used to and more.

Misc.

The only “side-project” worth mentioning is a bit of technical support I do for my good friend IMS with his fantastic fictional podcast, The Program audio series. Other than regular maintenance of the website, I implemented a very simple rating widget for individual episodes using Deno Deploy & Neon. I enjoyed the development experience between the two — both have their rough edges UI-wise, but the platforms themselves work well.

This was also my first time using Web Components in anger: I reused the Nude UI rating widget which pleasantly surprised me with its simplicity and ergonomics.

In other news, I slightly redesigned this website to keep up with the times. To top that, I wrote a very simple Markdown static site generator thingy in Rust, which was a very entertaining exercise. Now I have a bit more flexibility with regards to the organization here — let’s see if I actually make use of it.

Plans for 2023

Simplicity seems to have worked for 2021, so let's unimaginatively give that another shot. This year wrapped up with both Sara and myself being healthy, safe & sound, and having stable careers — can’t really ask for much more in these times.

Thus, in 2023, I'd like to:

graduate, and for bonus points, visit the graduation ceremony in Atlanta: it's cheesy, but COVID meant I couldn't attend my bachelor's ceremony, and it's something I'd be keen to experience;
help implement useful, impactful digital technologies in Zagreb;
read, listen to music, have fun;
shoot some photos, for bonus points — while travelling;
be a good and supportive partner;
live to see 2024.

2020: A Year In Review

2021-01-11T16:30:00+01:00

I liked going back to my previous “year in review” post, so let’s keep it up. I particularly liked how funny it looks in retrospect. Having good sense of humor is important.

So, 2020… Whew. Oh boy.

The Ugly

COVID-19 happened very early on. Luckily, it did not seriously affect anyone close to me, but it did change everyone’s approach to living.

In March, Zagreb got hit by a fairly strong M=5.3 earthquake. The city and its surroundings are still recovering: the renovation project is painfully slow, and the leadership was dreadful. Me and my partner were dislocated for a few months, but have since returned to our rental.

In December, Petrinja got hit by a devastating M=6.4 earthquake which basically destroyed several smaller cities, a lot of villages, and caused widespread damage in central Croatia. The aftershocks are still strong, and if Zagreb is any indicator, the recovery will be ongoing for years to come.

It’s been a traumatic year all-around, and I’m sure we’ll all be dealing with it for quite a while.

“Academics”

In 2018, I have started pursuing a BSc in Physics at The Open University. This year, I finally graduated — with first class honors. It was probably the pinnacle of the year, and one of my prouder achievements.

I was very happy with the distance learning approach. While I don’t see face-to-face teaching disappearing from the face of the Earth any time soon, I believe there’s much to explore and experiment within that approach to teaching.

I will be applying to Georgia Tech’s Online MS in Computer Science in the Fall 2021 semester. I seem to be on a roll, and it’d be a shame to stop now.

Travel

COVID-19 meant I was mostly roaming around Croatia: Vis, Prvić, Fužine, Ozalj, Plitvice. I very much did not mind that.

Books

This year, I’ve read a disproportional amount of fiction written in my mother tongue. I very much did not mind that, either. A couple, regardless of genre, that I found particularly impactful:

The Judgment of Richard Richter and W by Igor Štiks
Selected Poems by Constantinos P. Cavafy
Huzur by Martina Mlinarević Sopta
Meho by Amin Kaplan
Permanent Record by Edward Snowden
Patterns of Software by Richard P. Gabriel
Homo Faber by Max Frisch
Blue Horses by Mary Oliver

Music

I was slightly less mindful of music this year than usual. However, here’s a few albums I particularly enjoyed, in alphabetical order with Bandcamp or other indie-ish purchase links where available:

Ambrose Akinmusire: on the tender spot of every calloused moment
Ancst: Summits of Despondency
Brad Mehldau: Suite: April 2020
clipping.: There Existed An Addiction To Blood
Deftones: Ohms
Emma Ruth Rundle & Thou: May Our Chambers Be Full
Expander: Neuropunk Boostergang
Fiona Apple: Fetch the Bolt Cutters
FIRE-TOOLZ: Rainbow Bridge
Giorgi Mikadze: Georgian Microjamz
Greg Fox: Contact
Haken: Virus
Imperial Triumphant: Alphaville
Ingrid Laubrock: Contemporary Chaos Practices
Meslamtaea: Geketend in de schaduw van het leven
Open Mike Eagle: Anime, Trauma and Divorce
Rudresh Mahanthappa: Hero Trio
Run the Jewels: RTJ4
Sumac: May You Be Held
tētēma: Necroscape
The End: Allt Är Intet
The Ocean: Phanerozoic II: Mesozoic | Cenozoic
Thy Catafalque: Naiv
Villaelvin: Headroof
Zeal & Ardor: Wake of a Nation

Other

Photography

I bought a new camera (a Canon EOS M6 Mark II) and took a fair amount of photos. I don’t do much conventionally creative work so I’m enjoying playing around with the camera and post-processing — with various degrees of success. It’s also a great motivator to go outside and move.

I really liked this one:

For the first time ever, I made a photobook of photos taken during a trip I went to with my partner in 2018! It turned out really well, and I think I’ll be doing more of these in the future.

Soldering

Last year, one of my plans was to learn some electronics and embedded programming, and I’ve managed to at least get that going by buying a Lily58L keyboard kit and assembling the thing! I love it, and it’s the keyboard I now use daily. Here’s me trying really hard not to burn myself:

Thanks to Lovro for both teaching me how to solder & find my way around the project, as well as for taking this picture! It was an incredibly fun feat.

Politics

In the recent election, Možemo!, the green/left political party featuring yours truly as a member, ended up with four seats in the Croatian Parliament. As limited as it is, this was a remarkable result, and a refreshing change to the parliamentary structure.

Plans for 2021

This time I’ll try to keep it simple. Throughout 2021, I’d like to:

get vaccinated against COVID-19;
get into Georgia Tech’s MS in CS program;
read, listen to music;
take some pictures, preferably while travelling;
survive, preferably without any serious long-term consequences.

org the ultimate API client

2020-12-03T18:20:00+01:00

There’s a genre of software I like to call “GUIs for curl”: Postman, PatchGirl, and others. Their aim is to make web developers’ lives easier by providing nice graphical interfaces for executing HTTP requests. I never got around to get into a habit of using them since they either had clunky UIs or were not free software. Thus, I defaulted to using curl in a shell.

With time, I did come up with a wishlist of things I wish I could do with this setup. This boils down to being able to:

execute HTTP requests
parse, analyze and extract data from API responses
“compose” API requests by using parts of the response of one API request in the body of another
- this is most notable during authentication: somewhere early on in your workflow you’ll usually get an access token that you need to pass in each subsequent request
“bookmark” (persist) well-formulated API calls
annotate queries
tag the queries
share your queries with others

I tend to spend my working days in Emacs. Unlike the average Emacs person, I don’t really live in Emacs, thus I don’t mind an occasional context shift, yet a decent integrated solution is always appreciated. As it turns out, org-mode ticks all the boxes (as it usually does).

Executing HTTP requests

You could certainly use request.el to send HTTP requests out into the world. However, I just use an org-babel “shell” block and curl like a barbarian. I believe curl is the de-facto standard HTTP client, and it’s familiar to a lot of people. This approach has the extra benefit of transferring nicely into the command-line should it prove necessary.

Here’s a sample HTTP POST request:

* Example API Request: Authentication

  #+NAME: auth
  #+begin_src shell :cache no :results verbatim
    curl -X POST \
      --data "grant_type=password&username=nikola&password=hunter22&scope=all" \
      http://localhost:8080/v1/auth
  #+end_src

  #+RESULTS[...]: auth
  : {"access_token": "f744cb5c55d2946c4jzb3d7d61fb4850967.dae42e4e4d40", "expires": "..."}
  #+end_src

CTRL-c CTRL-c (or leader leader for evil folks) executes the block and outputs the result to be used further in the document. Which leads us to…

Parsing, analyzing and extracting data in API responses

Most APIs these days output JSON or XML, thus having results in the form of plain strings isn’t very useful.

Let’s say we’re only interested in the access_token property of the response to the request executed above. Again, you could very legitimately manipulate that data in elisp, but since we’re in the shell, we can pipe the data to another process:

  #+NAME: auth
  #+begin_src shell :cache no :results verbatim
    curl -X POST \
      --data "grant_type=password&username=nikola&password=hunter22&scope=all" \
      http://localhost:8080/v1/auth | jq .access_token
  #+end_src

  #+RESULTS[...]: auth
  : f744cb5c55d2946c4jzb3d7d61fb4850967.dae42e4e4d40
  #+end_src

This uses jq, a nice little tool for manipulating JSON documents on the command line. There are similar tools for XML/XPath as well.

Using API results as API parameters

Using some wonderful features of org-babel, you can trivially use results of previous commands in subsequent code blocks:

  #+begin_src shell :var t=auth :results verbatim :cache no
    curl \
        -H "Authorization: Bearer ${t}" \
        http://localhost:8080/v1/endpoint | jq .
  #+end_src

This will capture the result of our auth code block into a variable called t, which will then be available within the code block as a regular variable in your language of choice. org-babel will keep track of dependencies and offer to execute any code blocks that are necessary to figure out all of the variables used by the current one.

This has other handy use-cases as well. Need to generate some JSON for your API requests? Just do it in your favorite language:

  #+NAME: json_data
  #+begin_src python :results verbatim :python python3
    import json
    import random

    return json.dumps({"param1": random.randint(0, 100)})
  #+end_src

  #+RESULTS: json_data
  : {"param1": 49}

  #+begin_src shell :var data=json_data :var t=token :results verbatim :cache no
    curl \
        -X POST \
        -H "Authorization: Bearer ${t}" \
        -H "Content-Type: application/json" \
        --data "${data}" \
        https://httpbin.org/post | jq .
  #+end_src

Bookmarking, tagging and annotating API calls

org-mode files are text files, so each entry is automatically “persisted” when you save the file. Everything outside of code blocks is regular org, and org works well for taking notes! You can embed images, add tables, annotate, whatever. For tagging, I just use org’s built in tagging facilities at the heading level.

Sharing

org-mode files are plain text files, so anyone can open them in their prefered text editor and have a reasonably decent reading experience. But org can also export to various formats, and exporting to HTML will give you readable API documentation for free!

By default, org-babel will only export source blocks — not the results. This is good default behavior since sometimes API results involve secrets (e.g. access tokens). To override this, annotate your code block with :exports both:

  #+NAME: auth
  #+begin_src shell :cache no :results verbatim :exports both
    curl -X POST \
      --data "grant_type=password&username=nikola&password=hunter22&scope=all" \
      http://localhost:8080/v1/auth
  #+end_src

  #+RESULTS[...]: auth
  : {"access_token": "f744cb5c55d2946c4jzb3d7d61fb4850967.dae42e4e4d40", "expires": "..."}
  #+end_src

Problems

When exporting, org will export your code blocks literally — any variables will be exported verbatim and not replaced by its respective value. This may or may not be desired — I think it’s acceptable, but it can be confusing. There may be a snippet of Elisp somewhere that makes this go away.

Feedback

Feedback, corrections, comments & co. are welcome: you can write me an email or contact me on Matrix.

Living and Coding In Times of Crises

2020-03-28T11:08:00+01:00

Note: These are a few slightly melodramatic thoughts written in the aftermath of several somewhat traumatic weeks involving a pandemic, an earthquake, and a substantial change in the everyday. The few links that are scattered around I find interesting and important; the rest is here as a permanent reminder to myself. Hope everyone's well. Wash your hands.

I had hoped I would be able to write the word "crisis" in singular in the title of this post, but life tends to be a prescriptivist bastard. Writing this in the middle of a pandemic, after a non-catastrophic, yet devastating earthquake in Zagreb on Sunday, feels surreal. The apartment I just recently moved into roughed up, parts of it possibly significantly damaged, unable to socialize even in the most mundane of ways, exams canceled. Two events tearing into the fabric of what one considers the most social and the most personal, at the same time... and I'm lucky to be healthy, safe, and sound.

It's interesting how disruptive events quickly redefine the "normal". Just a few weeks ago, no one could imagine being quarantined indefinitely, yet here we are in week one of being unable to leave our place of residence. Redefining normal also tends to give way to malice, as we witness more and more calls to increase surveillance and invade people's privacy in order to (at least formally) keep track of the spread and unwanted public gatherings. Once again the political emerges as inseparable from the technological to the detriment of the techno-elite. Go figure.

Science, with all of its problems, gives us hope. Both of these events have been properly assessed: epidemiologists and infectious disease experts have been warning us of the possible consequences of SARS-CoV-2 weeks before the situation got out of control outside of China, and seismologists have been fairly clear that a strong earthquake around Zagreb is imminent. The problem with complex systems is that they're hard to grasp even for experts, and our intuition for statistics is slim to none. Even when we do manage to become aware of some aspects of the risks involved, this tends to fall apart as quickly as it materializes. Coupled with the fear of "collapsing markets" and their existential consequences, this often means we're more comfortable with the status quo than with taking action. Informed apathy can be as dangerous as uninformed sympathy.

As an aside, existential terror is a powerful weapon, and it was interesting to observe its effects on one's thoughts and approaches to life. I am well-aware that there are no reliable methods of predicting earthquakes to any precise extent, yet when on the day of the earthquake someone blurted out a hoax that "there's a stronger one coming at 8:45am", for a few moments it seemed like the most inevitable and obvious thing in the world. I think I've revisited that highly instructive moment more often than the earthquake itself.

Even though it's impossible not to be affected by this, people in IT, and primarily in software, seem to be in a unique position to handle this situation better than the average worker. There will be consequences, but the vast amount of money in tech means there's less chance of being fired, especially in times of enormous reliance on the tech infrastructure. The level of technological literacy gives us an enormous advantage in navigating the inevitable mess during the initial period of adjustment. A lot of us have been able to seamlessly switch to working from home, if we haven't already been doing so.

I believe this gives us a fair deal of responsibility, too: it's increasingly important to use our skills to help the ones in need. Large-scale tragedies take a psychological and organizational toll, and we have tools to help. This means being aware of the fact that the technology we produce is not as obvious as it might seem, and that people often need assistance and support which isn't a sign of weakness or lack of competence, but rather a natural consequence of using a new tool in an unfamiliar setting. It also means using the free time that isolation gives us to help people and organizations by providing them with necessary technological infrastructure and assistance.

More in-depth political analyses have been written by more eloquent and better-read comrades over at Pirate Care, focused on COVID-19 in particular, and by Tomislav, focused on the pandemic in combination with the earthquake. I can just echo that I find it important not to let our imagination atrophy and our empathy to subside, and that I hope the lessons we learn here will be the ones of solidarity and care. ☭

Book Review: “How to Read a Book”

2020-01-09T14:11:00+01:00

I don’t really review the books I read, but I decided to write a short blurb about the oft-recommended “How to Read a Book: The Classic Guide to Intelligent Reading” by Mortimer J. Adler and Charles Van Doren. I’ve originally posted it on Goodreads, but I’m publishing it here, too, for good measure:

There’s a lot to not like about this book: the slightly hermetic style, the occasional sexist slur, the subtly condescending tone, its exclusive–and, grantedly, somewhat apologetic–orientation to the “Western” literary canon, and the fact that the “recommended reading list” includes a single non-male author.

Keeping in mind that it was written in the 1940s, and despite these non-negligible shortcomings, I still find the book thoroughly insightful and valuable for what it is: a manual for analytical and comparative reading of “difficult” books, for whatever definition of “difficult” the reader might choose. It’s a deeply practical book, sometimes to a fault, and many of its takeaways might seem obvious. Yet, when outlined in a systematic and formal way, with plenty of examples and illustrations, I believe they give a good framework for approaching demanding literature.

Most importantly, the book forces you to think critically about the act of reading, and this might be its greatest contribution of all: it has certainly made me think about the way I approach books, and it has given me a few new tools to do so.

2019: A Year In Review

2020-01-03T10:20:00+01:00

I never wrote one of these, but I’ve come to realize that I find reading other people’s posts enjoyable and vaguely inspirational.

Without further ado, some things that stood out for me in 2019…

“Academics”

In 2018, I have started pursuing a BSc in Physics at The Open University. I transferred some credits from my previous unfinished studies, and ended up with four courses to go before earning the degree.

I have finished—with distinction—two of them in the year 2018/2019: “The Quantum World” (an undergrad quantum physics course) and “Electromagnetism” (an undergrad course in classical electrodynamics).

The entire pursuit was (and continues to be) fairly challenging. Distance learning is an interesting feat that seems to be working well. I believe it eliminates an entire class of fallacies I’m fairly prone on making, primarily the one of confusing “presence” with actual work.

This was also my most prominent “personal project” of the year, and it seems this is very likely to be the case for 2020 as well.

Meetups, Conferences & Talks

A couple of colleagues and I have started the Zagreb Rust meetup. It’s been reasonably successful, attracting a nice audience of 10-20 people at each of its eight iterations.

Talks:

Zagreb Rust Meetup: Developing web services in Rust
WebCamp Zagreb 2019: Getting to grips with Rust (a whole-day introductory Rust workshop, with Alan Pavičić)
Zagreb Rust Meetup: Asynchronous programming and Rust

Travel

London, Sicily (Castelbuono, Cefalù, Palermo), Dublin.

Books

A couple of books I’ve read that have been particularly impactful:

Make it Stick: The Science of Successful Learning ~ Peter C. Brown, Henry L. Roediger, III, and Mark A. McDaniel
Ultralearning: Timeless Techniques for Mastering Hard Skills ~ Scott H. Young
Atomic Habits: An Easy & Proven Way to Build Good Habits & Break Bad Ones ~ James Clear
Three Moments of an Explosion ~ China Miéville

Music

Last.fm is still keeping track of the vast majority of the music I listen to. I have yet to listen to a lot of albums that were very prominent in 2019, but a few that stood out (with Bandcamp links where available):

FKA twigs: Magdalene
clipping.: There Existed An Addiction To Blood
Matmos: Plastic Anniversary
Inter Arma: Sulphur English
Waste of Space Orchestra: Syntheosis
Black Milk: DiVE
Alexander Noice: NOICE
Liturgy: H.A.Q.Q.
LIUN + The Science Fiction Band: Time Rewind
Dawn Ray’d: Behold Sedition Plainsong
Cult of Luna: A Dawn to Fear
Sleater-Kinney: The Center Won’t Hold
Yatta: WAHALA
Glen Hansard: This Wild Willing
William Basinski: On Time Out of Time

I have also, repeatedly, returned to 2018’s “Safe in the Hands of Love” by Yves Tumor and “On Dark Horses” by Emma Ruth Rundle.

I traditionally go to many concerts, and the following made a special impact:

Vijay Iyer & Wadada Leo Smith at Muzička akademija, Zagreb
Godspeed You! Black Emperor at Tvornica Kulture, Zagreb
Homeboy Sandman & Edan at Vintage Industrial Bar, Zagreb
Peter Brötzmann & Heather Leigh at KSET, Zagreb
the entire lineup of Sarajevo Jazz Fest 2019, especially concerts by Miles Okazaki, The Ex and Joelle Leandre.

Personal (Tech) Projects

mjuziq3 is chugging along nicely with little to no intervention on my side. This year it hasn’t seen much love, but its interface has been updated to Bootstrap 4, and some of the interface elements have received a facelift.

mc is a small project for exploring Mars Climate data I have started working on with a couple of people from the Atmospheric Physics group at The Open University. Unfortunately, it hasn’t made much progress.

Other

enjoying my exploration of the tasty world of coffee
(equipment: Wilfa Svart, Hario V60, Aeropress)
politically, this year has been depressing, both globally and locally
The support for politics of solidarity has continued its decline, and while people luckily haven’t given up, it’s hard to be an optimist. I have no answers nor contributions here, but it has occupied a fair share of my mental bandwidth throughout the year.

Plans for 2020

The primary goal is to graduate and figure out if I want to pursue my academic “career” any further. Graduation assumes:

a passing grade in the Deterministic and stochastic dynamics course I’m currently attending;
a passing grade in the end-of-degree project course which involves an extensive literature review of a chosen field of Physics.

Project-wise:

encode some of my thoughts on and experiences with microservice-oriented web application architectures in Rust into a series of posts, code examples, and/or libraries;
bring mc into a usable (and useful) state;
containerize all of my personal infrastructure (I have a dream of being able to seamlessly move pieces of infra among a couple of servers as needed);
add a few more sources into mjuziq3 and rethink its interface.

Skill-wise:

learn some embedded programming & basic electronics skills in order to be able to follow things like these;
become comfortable with a development environment for one of the more prominent operating systems for the PinePhone;
understand the basics of quantum computing, both theoretically and practically.

Personally:

finally achieve my weight goal of dropping below 80 kg;
successfully spend the year living with my lovely partner.

Developing Web Services in Rust: my talk at the Zagreb Rust Meetup

2019-03-08T17:30:00+01:00

I've given a short overview of Rust's support for writing web services at the Zagreb Rust meetup. It was all in Croatian, but there's some code with the occasional comment in English which may or may not be useful.

There's also an org-mode file in the repository, containing the vast majority of the stuff I've covered in the talk. Incidentally, GitLab does a far better job at rendering org-mode files than GitHub does, so you can enjoy a beautiful render without notable loss of content.

Shoving Your Application Code Into the Web Server: my talk at WebCamp Zagreb 2018

2018-10-12T00:00:00+02:00

It's been a while since I've given a talk: my website says it's been more than 3 years. This year I've decided to break that streak, and submitted a talk called "Shoving Your Application Code Into the Web Server" to WebCamp Zagreb, and it got picked! The talk served as a short introduction to the nginx module system with a focus on OpenResty and its ecosystem.

The conference was a blast, as always. I wasn't in the organizing team this year, but the crew did an amazing job (again, as always). Zagreb is lucky to have an event with such a lengthy and strong tradition.

Below is a very approximate transcript of the talk along with the slides, skipping the boring introductory part where I talk about myself. It might contain some stuff I forgot to say during the talk, and it might be missing some stuff that I did say on the talk, but such is life. The structure was shamelessly borrowed from Maciej Ceglowski. The page will be updated with a recording once it's available.

Clicking on a slide will open a larger version in a new window. You can also download the PDF with all of the slides.

The Web Server

My day job mostly revolves around dealing with components that end up speaking HTTP, either between each other or with the outside world. And where there's HTTP, there's bound to be a web server.

If you're like me until a few years ago, you probably don't think about the web server too much. Sure, you may have tacked on a few modules, and you may have written a few neat configuration files... but once it's up and running, you probably think of it as this fairly stable black box that somehow turns incoming HTTP requests into something your webapp can understand. I hope one of the key takeaways of this talk that I'll offer to you will be that your web server can be used to do much more than that.

nginx

A prime example of a webserver is nginx. It's been built back in 1999 in order to tackle the so called c10k problem, which boils down to being able to handle 10 000 concurrent TCP/IP connections from a single machine. While this may sound trivial to you today with all of the hardware resources we have at our disposal, it was far less of a stroll 19 years ago.

Today, nginx powers between 30% and 40% of the public internet. If your little corner of the public internet isn't within this bracket, bummer — we'll mostly be dealing with nginx and its ecosystem throughout this talk. However, I hope this will at least make you consider using nginx for your next project.

There are two properties of nginx that will be very important for this talk. The first is that nginx is modular; i.e. it has an API and allows us to build extensions that augment its functionality.

The second important property is that it's built on an asynchronous, event-driven architecture, which is the key differentiating factor that allowed it to tackle the c10k problem in 1999, when most web servers used a thread- or process-based approach to handling multiple concurrent connections.

nginx has a very rich module system, encompassing modules for most of web-development-related tasks you might imagine. Parsing JSON, querying PostgreSQL databases and various other data stores, authenticating on LDAP servers — you name it.

The limiting factor is that the functionality of these modules is exposed through the nginx configuration language. While this is neat for those times when you simply want to map an HTTP location to a simple SQL query and return its result as a JSON object, doing any sort of serious business logic simply isn't viable with the configuration language nginx provides.

Occasionally, you just might want that tiny bit of non-trivial business logic in there. For example, you might want to authenticate on an LDAP instance and ask a Postgres DB about the upstream server to which you need to forward your HTTP request. Or, you might want to add some additional HTTP headers before forwarding the request further, with the headers depending on some heavy business logic. Or you might simply want to change the wire transfer format because something behind your web server doesn't speak plain old HTTP 1.1.

These are all legitimate requirements that might not warrant a whole webapp on their own, but might not fit into the architecture of your existing webapp (or webapps). Since you have all of the modules needed within nginx already, it would be really nice if you could somehow use them to do at least some of these tasks.

So, we come to the central question of this talk: what if we could script these nginx modules with something other than the nginx configuration language?

Let's put that aside for a moment and talk about Lua for a little bit...

Lua

Lua is a nice, small dynamic programming language with very clear semantics and a minimum of two amazing implementations. It's not entirely unlike JavaScript, but back when it was originally conceived, it was meant to compete with Scheme and a neat little language called Tcl.

It's written in ANSI C, which means it's highly portable: you can run Lua on any system that has a compliant compiler, which is basically any system in existence. Lua is also trivially embeddable, meaning you can simply include it into your existing C/C++ app and use its beautiful API to allow your users to script your software.

Another thing Lua has going for it is LuaJIT, which is arguably the best dynamic language just-in-time compiler in the world. This, of course, comes with a 400-page disclaimer, but whether you're convinced or not, LuaJIT is an engineering marvel: it's an insanely well-optimized and performant VM worth looking into.

Here are a few examples of Lua which should allow you to get a feel for the language if you've never seen it before.

This first example is a very obvious factorial function, nothing too exciting...

This other example, shamelessly borrowed from Programming In Lua, 1st ed., outlines some less obvious features of the language like the module system and first-class functions.

So, we know that Lua is easily embeddable in C, and we also know that nginx is written in C... The question kinda asks itself: what if we could use Lua to script some of those nginx modules (and more)?

ngx_http_lua_module

Luckily, far more capable people than me already came to this brilliant and completely non-obvious conclusion, and built ngx_http_lua_module. This module allows us to embed Lua code in various phases of nginx's worker process, displayed in the handy chart on the slide.

The two big ones we'll be dealing with today are content_by_lua and balancer_by_lua just because they're the most obvious, but all of them are fairly useful.

Let's say you've been tasked by the business with a very important task of coming up with a /brew endpoint that:

responds with HTTP 418 "I'm a teapot" if it finds the words "coffee" or "beer" within the response;
responds with HTTP 200 "OK" if it finds the words "tea" in the response;
responds with HTTP 400 "Bad Request" in any other case.

We’ve all been there.

You could start with a fairly simple nginx configuration file like the one on the slide, the only real difference being the content_by_lua_block that allows us to execute arbitrary Lua code in order to respond to the HTTP request on this location.

...and your arbitrary Lua code might look something like this.

Now let's say you've been tasked with the far less common and far less important task of forwarding your incoming HTTP requests to an upstream that's dynamically defined in a Redis datastore.

You might start again with a fairly simple nginx configuration file, defining that all of your incoming requests should be forwarded to an upstream called backend. This upstream would be defined with a fake IP address, and a balancer_by_lua_block that would allow us to execute arbitrary Lua code in order to set the real upstream location.

...and again, the arbitrary Lua code might look something like this. This isn't necessarily executable and lacks a lot of error handling logic, but the gist of it is there: you query a Redis instance in order to get the upstream host and the port, and then use the exposed APIs in order to set the upstream peer to the parameters you just read.

This looks deceptively simple, and by simply looking at this you would probably say that this code is 100% synchronous. But, your Redis instance might be in China... or down. You wouldn't want your nginx worker process waiting for the Redis response! While it's waiting, it's unable to process any more incoming HTTP requests, basically murdering your performance (and, almost certainly, access to your webapp in general).

However, using the magick from nginx's APIs and ngx_http_lua_module, all of the resty.* and ngx.* APIs you see are completely non-blocking, allowing your worker process to keep on processing further HTTP requests.

OpenResty

I hope you're intrigued by now, but there's a catch: ngx_http_lua_module isn't included in nginx by default. This means you either have to depend on your operating system having a package (many do), or build it yourself.

Enter OpenResty!

OpenResty is a bundle that contains nginx, LuaJIT, and a bunch of non-blocking libraries that allow us to do many of the things we've talked about.

It has been used by the likes of Tumblr, Alibaba, CloudFlare, and many others. CloudFlare has since moved on from OpenResty, but it had used it for a long period of time for many of its load balancing needs; they have also employed the principal developer of OpenResty and financed a lot of the development behind the project.

Since ngx_http_lua_module is a fairly central part of this whole thing, you'll often times hear "ngx_http_lua_module" and "OpenResty" used interchangeably. Don't let this confuse you, and for all intents and purposes, this is the same thing.

While your ops practices may vary and you might want to build the entire thing yourself, OpenResty seems to be the preferred way of using nginx with the Lua module.

Non-trivial Usage

All of our examples so far have been fairly simple. I do hope no one believes that keeping your business logic in nginx configuration files is a good idea, though! In order to write actual working software with this, we do need a few more tools.

ngx_http_lua_module does allow us to load Lua code from files on the filesystem instead of hardcoded blocks in the config file: we can use *_by_lua_file instead of *_by_lua_block. This allows us to nicely structure the code using standard Lua mechanisms like modules.

Since we're using a standard Lua runtime within nginx, LuaRocks is fair game: we can use it to download & load 3rd party modules from the LuaRocks repos.

For testing, you can use standard Lua tools like busted to unit test your Lua modules. For end-to-end testing you can use Test::Nginx::Socket, a Perl module written by the author of OpenResty, which allows you to define your nginx configuration, HTTP request and HTTP response in a single unholy amalgamation of a file (gotta love Perl developers!). It will then load an nginx instance with that configuration, execute the HTTP request and assert the equality of the responses.

Since the focus of OpenResty is high-performance code, profiling is important. Again, the author of OpenResty has a nice set of SystemTap-based scripts which allow you to do all kinds of on-CPU and off-CPU profiling, and generate flame graphs in order to identify slow (or blocking!) parts of your code.

What's Not To Like?

One of the first things people notice when diving into any kind of Lua development is that the ecosystem is fragmented. LuaJIT is in maintenance mode, and is compatible with the reference implementation, PUC-Lua, until (give-or-take) version 5.2. PUC-Lua has since moved on, and is currently heading towards version 5.4.

Operationally, this isn't that huge of an issue: most of the community is focused on LuaJIT simply because of its insane performance. However, it's unclear whether this will be the case for forever.

The second problem is: it's not easy being asynchronous. Even in runtimes that push asynchronicity by default, like Go and node.js, it's not always easy to guarantee non-blocking behavior. This is even more prominent in Lua, where asynchronicity isn't the focus.

This can be remedied by only using the libraries from the nginx and OpenResty ecosystems that are built with this in mind. If this is not an option, an alternative is to dig into the nginx C API and write the library yourself in a non-blocking fashion, which may or may not be viable depending on your familiarity with C.

Final Words

With all of this said and done, we come to what could comfortably have been an alternate title of this talk: OpenResty gives you the ability to configure your web server in a Turing-complete programming language. But even more than that, OpenResty allows you to do it using a very comfortable, highly performant programming language.

In theory, you could write your entire webapp using OpenResty. In practice, this will heavily depend on the availability of async libraries and the overall fitness of your project to nginx's architecture. However, if you do have a project that fits into the asynchronous, event-driven nature offered by this ecosystem, I do hope this talk managed to convince you to give OpenResty a go.

Thank you!

Miscellaneous Org Mode Tips & Tricks

2017-10-20T10:08:31+02:00

Org mode is one of the main culprits for My Great Switch to Emacs of 2016. I've been very fond of the idea of my life in plain text; I've seen it in action a few times, and it always felt like magic in a very portable file format.

I'm still a rather noobish user of Emacs: as a former Vim user, I'm very happy with my Spacemacs setup, yet it's very unamusing. But, I think I've collected a few interesting org mode tips & tricks that people have shown some interest in:

Export to Google Calendar

I'm a big fan of the agenda view, but I'm also a heavy Google Calendar user. I never really wanted a true two-way integration between the two, but some sort of a setup where my org mode schedule would show up in my calendar sounded good.

Org mode supports exporting your agenda to iCal, so it's just a matter of:

running this command periodically,
making sure the resulting .ics file is available over the internet, and
importing the .ics file into Google Calendar as a new calendar.

The solution to #1 is a ridiculously simple timer I have in my .spacemacs:

(defun export-org-agenda ()
  (if (eq major-mode 'org-mode)
      (org-icalendar-combine-agenda-files)))
(with-eval-after-load 'org
  (setq org-ics-autosave
        (run-at-time "1 min" 3600 'export-org-agenda)))

The only "smart" thing about the function above is that it'll run only if you have an org buffer open anywhere in Emacs. I vaguely remember having some issues with org-icalendar-combine-agenda-files when it would run in a non-org buffer.

I have outsourced hosting this file to Dropbox. You can configure the path to the resulting iCal file with

(setq org-icalendar-combined-agenda-file "~/Dropbox/cal.ics")

Dropbox can generate a publicly-accessible URL for this file, and you can then import it to Google Calendar, solving #3. Alternatively, a few more lines of Elisp can be added to the timer to copy the file to a remote server.

Project Management & Gantt Charts in Org Mode

There has to be a way of creating Gantt charts from org mode files! -- me, mid-2017

Enter TaskJuggler.

Org mode has some support for creating .tjp files from org mode outlines. It barely scratches the surface of what TaskJuggler can do, but it supports the basics (assignments, dependencies), and generates decent reports out of the box, including nifty Gantt charts.

The docs linked above are slightly outdated, i.e. they cover an old version of TaskJuggler that used Qt. The new version of TaskJuggler has no UI, but rather just a CLI tool that spits out HTML files that can be viewed in the browser.

One property that I found quite useful is start: TaskJuggler will try to automatically allocate time for the tasks based on your assignment and dependencies, but often you'll have a set start time for your task. Slap :start: 2017-10-18 to your task and it will start on October 18th; this will also take this fact into consideration while automatically scheduling the rest.

If you're working in a larger team, the automatic resource allocation feature is a lifesaver. For anyone doing any sort of project management, I strongly suggest looking into this.

Spacemacs: Org Agenda Transient State

I stumbled on this by accident while fat-fingering the spacebar and Alt keys, but the transient state for the org mode agenda is a well-documented feature.

In the agenda view, hit meta + Space (usually Alt + Space), and you'll get a nifty minibuffer with a bunch of options.

Since I have my agenda open at all times on a separate workspace, the one I use the most is ft (filter by tag) — I usually display only my work tasks when I get to work in the morning, and then switch to my personal tasks in the afternoon. fd deletes all active filters.

We Made a Conference (For Fun and No Profit)

2017-10-15T00:00:00+02:00

Last week I've had the pleasure and the opportunity to work with a team of fine people on delivering another WebCamp Zagreb conference. WebCamp is a yearly community event organized by members and friends of various meetups and user groups in Zagreb on a fully volunteer basis.

I've joined WebCamp in early 2016, after a few of the core organizing members left due to lack of time. Before that, I've visited as an attendee and a speaker. I was thrilled that a big, non-profit conference with no corporate brain-washing took place in Zagreb, so I stepped up and joined the organization.

Since then, I've been responsible for managing the day-to-day administrative and accounting issues for our little NGO, and coordinating the sponsorships of the conference.

How to Organize a Conference Without Really Knowing What You're Doing

In early 2016, I had no idea what I'm doing. I had experience doing the paperwork chores because I ran my own company, but NGOs have their own set of subtly different rules. Fundraising-wise, WebCamp was an established conference with quite a reputation by then, so I kinda assumed that we shouldn't have too much trouble finding sponsors, but my experience in actual sales were non-existent.

That fact is visible in the 2016 budget: the income was noticeably lower than in 2015, mostly due to the lack of sponsors. We weren't able to find a diamond sponsor, and the interest was tangibly lower. Ultimately, we managed cut a few expenses here and there, and the net balance of the conference was positive. We delivered a decent event which even left us a lump of capital for the 2017 edition.

That whole episode was somewhat defeating. It's hard to convince yourself to continue doing something when you have hard proof you're not doing it all too well. But a sample of one isn't really statistically relevant, and not a really good argument for quitting. The team was pretty enthusiastic despite the initial reluctance, so we decided to give it another go.

How to Organize a Conference With a Bit More Insight and a Few Good Tips

Based on a tip by our friends from Slovenia, we have decided to do one additional thing which has worked well for them: we sent out a "call for sponsors" email to our mailing list asking our newsletter subscribers to help us recruit sponsors within the companies they work for, or to simply suggest any ideas for companies we could contact. In parallel, I have sent out a bunch of emails both cold and hot, and... waited.

It turned out to be quite a success. We sold out almost all of our sponsorship tiers, the income was the highest so far, and this year we have a really decent sum of capital for the next WebCamp, as well as any other projects that we might want to do.

There are a few other things worth mentioning that aren't a consequence of the budget (or at least not a direct one): we've had the lowest amount of no-shows yet (below 5%), we introduced a talk committee with several trusted members of the community which resulted in some of the best WebCamp talks yet, and more.

See You Next Year?

Organizing an event for 800+ people for two days is no easy feat. WebCamp, luckily, has a really motivated team, and a set of partners that make things easier. At times, it's incredibly frustrating, but the net result is a bunch of new acquaintances, an incredible number of fun chats with the visitors, and an event that seems to be important for the regional tech community.

I'm especially glad to see a significant number of people from abroad are visiting the conference, and sharing knowledge and information. I hope this trend will continue, and I hope WebCamp as an NGO will continue serving as a catalyst for these practices in the future — through the conference, and beyond.

Music I've Listened To - Week of March 7th

2016-03-13T00:00:00+01:00

I try to listen to a lot of fresh, interesting music. Here's a choice of 5 records that have especially caught my interest during the last week.

Ministry of Spontaneous Composition by D.C. Improvisers Collective

Source: Avant Music News, preview: Bandcamp

I'm a sucker for witty and funny album & song titles, and that's one of the primary reasons this record piqued my interest. It's a brilliant, interesting feat by this Washington D.C. based improv collective. Sincerely humorous, eclectic, and approachable without ever winding up in the prosaic, it's one of my favorite jazz-related releases of the year so far.

Skáphe² by Skáphe

Source: Angry Metal Guy, preview: Bandcamp

If there's one record I've listened to in my life that I'd have to pick out that represents hopelessness and the nihilistic in music, Skáphe² would probably come to mind first. Unlike other releases in this vein, Skaphe offers no catharsis. Even the short hint of optimism in the album's final track serves only as a reminder of what could've been - but by then, the band made damn sure you're aware that it never will be.

On the Nature of Thingness by International Contemporary Ensemble

Source: Avant Music News, info: Starkland

ICE is a US-based collective dedicated to playing contemporary classical music. On the record, they play music composed by two of their members. It's a tour-de-force of modern composed music played with an array of unusual instruments like parts of a broken music box. It also includes an intriguing interpretation of Hugo Ball's Dada Manifesto called "Dada", which was probably the piece that caught the most of my attention.

Blister the Maw by Sonance

Info: Holy Roar Records

Combining noise, ambient and post-hardcore / sludge is nothing too new. However, Sonance takes it to the next level on this short cassette. The soundscapes in the first and longest piece are almost soundtrack-like (a very evil, tormenting soundtrack), peaking into a wall of guitar drones, noise, screams, and haunting whispers. Resolution comes in the form of the acoustic short track "Cherry", but doesn't last long - the album's second half is more classically sludgy, with great, crushing guitar work.

Different Selves by Shapednoise

Source: A Closer Listen

You could think of Different Selves as an electronic companion to Skáphe's record. The underlying assumption, to me, seems to be similar: complete abandonment of hope and any kind of optimism - not just in human existence, but the entire universe. Dark, heavy music obviously inspired by techno and industrial traditions, but with heavy influence of noise and compositional tendencies in modern electronic music. Shaping the noise indeed.

Impressions from WebCamp Ljubljana 2015

2015-03-17T10:45:37+01:00

I'm a huge fan of conferences: I find it to be an excellent way of absorbing new ideas, and meeting new people who deal with things which may be outside of your comfort zone. I especially like community conferences, as they tend to be far more relaxed, inclusive, and untainted by corporate interests.

That's why I really love WebCamp Ljubljana: it ticks all of the checkboxes above, and I really find the community over there interesting and inspiring. I've tried to visit most (if not all) of the editions so far, and it was nice seeing it grow from a tiny barcamp to a decently sized conference without losing any of the positive vibe.

Eight of us from several programming communities from Zagreb decided to rent a van and visit this year's edition.

Due to almost-standard last-minute preps for my talk, I had to miss two interesting talks, but I did manage to catch Luka's talk titled "What to do when a client wants to serve 110 million geotargeted banners from a VPS?", and Domen's talk on revolutions in Linux distributions, both of which were really really good and informative.

Although Domen's talk covered a LOT more ground than just NixOS, one of my main takeaways and the primary to-do list item is checking out NixOS in a bit more detail. It seems like a potentially excellent take on package and configuration management at the OS-level.

Luka's talk was an interesting mixture of advice on soft- and hard-skills, but I think it primarily served as a reminder we shouldn't ignore the non-tech aspects of our field and be afraid of stepping outside of our comfort zone when we're trying to solve a problem. It reminded me of, and motivated me to re-read The Ten Commandments of Egoless Programming.

This year I gave a talk on Clojure which was a bit of a different take on the identically named and themed talk from WebCamp Zagreb. I definitely liked this version of the talk better, and it seemed to be accepted well by the audience — hopefully the audience shared my positive sentiments.

Lightning talks held after the lunch break were also fun: I love the way the organizers made sure the talks really were "lightning", and thus were all presented from a single laptop, with a person from the organizing committee changing slides and making sure everyone gets at most 5 minutes for their talk. Željko, another member of our delegation from Zagreb, gave a lightning talk on solving Rubik's cubes.

Ivan also represented the Croatian community and held a lightning talk on WebCamp Zagreb, a not-entirely-different conference taking place in Zagreb on October 3rd & 4th. We (Ivan, Luka and I) had five tickets for the conference to give out during our talks, and it was nice to see there was interest from our friends and colleagues from neighboring countries. Yay!

Our friends from PHP Srbija, the Serbian PHP community presented their conference on software architecture and design patterns called SoliDay. The lineup at that conference is amazing, and I'll definitely go and visit.

The sponsors were quite interesting, thus I finally had the chance to try CogniTea. It's tastier than it sounds, and I like the concept a lot. Unfortunately, their intl. shipping is a bit too much, but I might give it a go every now and then.

All in all, I've enjoyed the conference, and I'm looking forward to upcoming editions. I've managed to catch up with a lot of familiar folks, and have a chat with some new people as well, which definitely made the trip to Ljubljana worth it.

Forcing Korma to use UTF-8 in MySQL connections

2015-02-04T15:02:48+01:00

I'm a huge fan of Korma, a Clojure DSL for relational databases. It makes handling connections (c3p0 for the win!) and writing queries in Clojure a breeze, and so far I haven't found any huge drawbacks.

One of the issues I have run into is inserting UTF-8 encoded data — any non-ASCII characters would end up as a question mark ("?") in the database. This led me to believe that Korma isn't defaulting to the UTF-8 encoding, so I went my merry way to find a way to convince it to do so. GitHub Issue #150 pointed me in the right direction, but the ultimate solution was lurking in the somewhat unrelated Issue #213.

I've used the default (defdb quux (mysql ...)) way of establishing a connection, but that one doesn't allow us to define the encoding. The trick is to pass the entire "raw" connection map by hand:

(defdb quux {:classname "com.mysql.jdbc.Driver"
             :subprotocol "mysql"
             :subname "//localhost:3306/quux"
             :useUnicode "yes"
             :characterEncoding "UTF-8"
             :delimiters "`"
             :user "zerocool"
             :password "hunter2"})

That's about it! Happy hacking.

EuroClojure 2014: Notes & Impressions

2014-06-30T10:13:50+02:00

Although Clojure isn't our company's primary language, we've decided to go ahead and visit this year's EuroClojure in Krakow — I've always been impressed by the community behind the language, and the list of talks and speakers, as well as the recent developments in the Clojure ecosystem, guaranteed it won't be boring.

Long story short: it was worth every minute spent on travel — plane tickets were ridiculously expensive so we decided to drive. Approx. five hundred miles in one direction does take its toll, so I turned out to be exhausted after the trip, a sentiment which lingered throughout our stay in Krakow. Oh well, win some, lose some — Central Europe is quite nice this time of year.

Luckily for me, I still don't have a driver's license, so the burden of driving fell onto my good friend and business partner, Boni, who took it like a champ that he is. :)

Don't remember the last time I've attended a conf. where I was totally thrilled and jam-packed with new info after every talk. #EuroClojure
— Nikola Plejic (@nikolaplejic) June 26, 2014

The Conference

The conference itself was top-notch, both content-wise and organizationally. I really liked the more relaxed, informal, hacker-ish atmosphere. The venue made that pretty easy — a beautiful, cozy museum of Japanese art and technology, right next to the southern bank of the Vistula river, not too far from the city center.

As I tweeted at some point, I don't remember the last time I went to a conference where I thoroughly enjoyed each and every talk, and learned a bunch of cool stuff along the way. The eclecticism of the talks was impressive, and I applaud all of the speakers on their far from trivial efforts. I think a lot of conferences could learn a thing or two about appropriately expanding their list of topics and interests from EuroClojure.

What follows are some of my notes and impressions from a couple of selected talks — ones which hit close to home, or caused an "aha!" moment of sorts. For slightly more thorough notes, I strongly suggest you take a look at Philip Potter's incredible writeup.

The Talks

When I say "eclecticism", I do mean it: the whirlwind started with Fergal Byrne's talk on Hierarchical Temporal Memory, an intriguing approach to machine intelligence using state-of-the-art neuroscience research. I wasn't previously familiar with HTM, but the talk was pretty high-level, cumulating with an introduction to Fergal's Clortex, an equivalent of NuPIC in Clojure. His description of software development as more of a science rather than engineering resonated pretty well.

Gary Crawford's talk on sentiment analysis of tweets was just what the doctor ordered — it's something we've been working on at Neutrino. His interesting approach uses Redis' bit operations for categorization and quick population counts, something I definitely plan on exploring further. Along with his theatrical delivery of the Leiningen quote, the mention of Datensparsamkeit and his plea for privacy awareness when collecting data turned out to be one of the more memorable moments of the conference.

The best thing about Idris is that it lets you make condescending remarks about Haskells type system - @ctford #euroclojure
— Erik Assum (@slipset) June 27, 2014

Chris Ford's talk on Idris was a surprising one. Although he barely mentioned Clojure, it was a great, succinct overview of Idris' type system motivated by the explanation of the Curry-Howard correspondence: types being propositions (or theorems if you'd like), and functions being proofs. A nice dash of advanced type systems at a dynamic language conference, with a refreshing approach not as focused on theory. Good to see Clojure devs open to Idris! :)

Day two was also a lot about Om, with both David Nolen's keynote, and Anna Pawlicka's example-packed talk on reactive data visualizations. Both talks finally made a couple of things about Om and React click, and ultimately made me play around with the libs over the weekend. First impressions are brilliant, and even in its alpha stages Om has a bunch of potential to significantly change the way we think and act about UIs (it was about time!).

The Bottom Line

I'm doing great injustice by stopping here because there's a lot to be said about each of the talks, but Philip's notes linked above, as well as the eventual videos of the talks, will probably be saying a lot more than I ever could. I'm definitely looking forward to tinkering with a lot of cool new things presented — it really is an exciting time to be interested in new languages & technologies.

Thanks to the organizers, thanks to the speakers, and thanks to everyone present. Until next year! :)

On Asking the Right Questions in Internet Communities

2014-05-18T12:28:32+02:00

As a member of a multitude of programming communities during the past 10-12 years, I've always been frustrated and somewhat intrigued by people who jump onto a board or a Facebook group asking for someone to contact them in order to explain "a thing or two" about technology X or feature Y instead of simply asking the question there and then.

The Xs and Ys are usually so broad that there's no clear indication on whether it's some low-level kernel-layer issue the person is having, or a trivial 30-second CSS problem. So I'd like to stress out a very important, yet neglected part of a developer's toolbox:

You Really, Really Need to Know How to Ask the Right Question

When you're asking a question online, you're more-or-less expecting someone to drop whatever they're doing and spend a certain amount of time to come up with a piece of information, very likely to your significant benefit. Thus, it's almost crucial to make the job as easy as possible for that person.

By spending some time and thoroughly researching a question, and formulating it in a clear, non-ambiguous way, you're not only showing respect towards the person who's about to give you an answer, you're also making sure the right person gives you the answer.

Vague Questions Give Vague Answers

When I see a well-formulated question, it's immediately obvious whether I can answer it constructively. The clearer that is, the more likely I am to write an answer. The less vague the question, the less time needs to be spent on hunting for additional information possibly crucial for a correct answer.

Hunting for details or further explanations of the problem in order to answer someone's question for free isn't a favorite passtime activity of many. The amount of hunting and the degree of triviality of the details are directly correlated with the chances of someone simply giving up and spending their time on something more productive.

Asking the Right Question Is Half Of The Answer

By taking the time to formulate a question, you'll need to explain a lot of the nitty gritty details to yourself before outsourcing that to a random stranger. This is not only a brilliant learning experience in itself, it's also a great opportunity to make sure you're not missing something very obvious.

You'll need to make sure you understand every step of the way up to the point of encountering the problem, and very often that's the key step towards solving the problem on your own. I've spent a lot of time carefully writing forum posts and StackOverflow questions just to get to that "AHA!" moment, resolving the issue by myself.

A Little Effort Goes a Long Way

People wrote entire essays and HOWTOs on the subject. One of my favorites is Eric S. Raymond's How To Ask Questions The Smart Way which should be required reading for anyone asking questions in any shape or form, ever. It's a lengthy, but excellent summary of things to keep in mind when asking for help.

Ultimately, by investing some time into a proper inquiry, you'll not only help yourself by making sure your question gets answered quickly and precisely — you'll also help your fellow programmers in distress by making it easier to find the very likely answer using search engines when they encounter a similar problem.

This is the key non-technical tool in your arsenal: use it well, and everyone benefits; use it badly, and you'll be ignored, get a low quality answer, or be called out for lack of respect towards fellow community members.

Developing and Deploying ASP.NET MVC Applications On Ubuntu Linux with Mono, nginx and MySQL

2011-03-21T13:10:04+01:00

Mono is moving forward at an impressive pace: the team at Novell and the Mono community deserve some massive respect. In the more recent versions, support for ASP.NET MVC emerged and the new Microsoft library became a part of the core. Combined with XSP (the Mono web server) and its FastCGI server, it became possible to serve ASP.NET MVC applications from your Linux machines.

This post is a quick summary of my first steps in creating a development environment and setting up a server for ASP.NET MVC on Linux. Tools of the trade will be Ubuntu 10.04 (Lucid Lynx), the nginx web server and XSP’s FastCGI server. I’ll assume you have a working setup featuring nginx and MySQL on your server – configuring these is beyond the scope of this article.

Much of this was never tested in a production environment. I have yet to develop a non-trivial application running on top of all of this and I can’t guarantee everything is bug-free and 100% functional. People are using Mono in production, the whole thing looks and feels really solid, but definitely make sure you test everything before diving in.

Mono.GetLastVersion();

Ubuntu depends on Mono quite a lot, so don’t expect to find the latest and greatest version in your package manager. There is some comfort in the form of Badgerports, but it’s LTS-only, and it’s usually a bit behind the latest Mono stable. The solution is to compile Mono from source, which is actually a lot easier than it sounds.

If you feel you can live with an older version of Mono and are using a long-term supported release of Ubuntu, go ahead and grab the Badgerports repository and install their Mono packages. The crew is doing awesome work and the backport works great. Compiling stuff from scratch means you have to keep an eye out for security updates and recompile when necessary to keep your server safe, which can be stressful. If you really like living on the edge, follow the instructions below.

The whole process is made easy by a nice shell script written by Patrick McEvoy which does all the heavy lifting. The script is nicely written, so if you don’t like running random stuff from the web as root (and you shouldn’t!), feel free to take a peek, see what it does and do the whole thing by hand.

Clone the Git repo or fetch the script directly from GitHub and see what the script does by typing ./mono_build.sh -h (you’ll have to chmod +x mono-build-sh if you already didn’t). The choice between the correct flags depends on what you’re configuring:

for my development machine, I chose to build “just Mono” (the -r flag), and then added gnome-sharp and monodevelop afterwards (-m mono-addins gnome-sharp gnome-desktop-sharp monodevelop);
for my VPS, I chose to build “just Mono”, without any additional modules.

Run the script with your selected parameters (don’t forget to specify the prefix!) and grab a cup of coffee as it could definitely take a while.

You may get compile errors while installing MonoDevelop. Depending on your current Mono configuration, you may need to uncheck certain MonoDevelop packages in the configure phase: I only checked “main”, “extras/MonoDevelop.Database” and “extras/MonoDevelop.Debugger.Gdb”; the “extras/BooBinding” and “extras/MonoDevelop.MonoDroid” packages I tried to install caused the compiler to choke. If you make a mistake in this phase, go to the MonoDevelop source directory, and do a sudo ./configure --select; choose the packages and then try to recompile with mono_build.sh.

When finished, you should have a fully-functioning version of Mono in a directory of your own choice. Follow the instructions to enable and test your new installation, and buy Patrick a beer for his awesome work.

Setting up nginx and FastCGI

You don’t need to set up FCGI on your development machine – you can happily use the standalone XSP which was built as a development server. XSP loads automatically when you run your app from MonoDevelop.

XSP provides a FastCGI server, which is an excellent way to make Mono and nginx talk. For this to work, you’ll need to know the exact location of the fastcgi-mono-serverX (where X is one of { “”, “2″, “4″ }, depending on the ASP.NET version you’d like to use). If you installed the Badgerports backport, it’s probably in your PATH; if you compiled from source, it’s in $PREFIX/bin/fastcgi-mono-serverX.

Now we need to point nginx to the FastCGI binary. Here’s a sample configuration file:

server {
    server_name {SERVER};
    access_log {ACCESSLOG};
    root {ROOT};
# magick start!
location / {
index index.html index.htm default.aspx Default.aspx;
# DEFAULTROUTE is the default route of your app; e.g. Home/Index
fastcgi_index {DEFAULTROUTE};
# choose a free port; e.g. 9001
fastcgi_pass 127.0.0.1:{PORT};
include /etc/nginx/fastcgi_params;
}

# /Content contains just static files - we don't need
# no FCGI to serve those!
location /Content/ {
}

}

You can easily deploy your ASP.NET application to {ROOT} by using MonoDevelop’s “Deploy to Web” functionality (Tools – Deploy to Web).

Now, edit /etc/nginx/fastcgi_params and add the following two lines defining certain environment variables the FastCGI server expects to find:

fastcgi_param PATH_INFO ""; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

Finally, start the FastCGI server itself:

$PREFIX/bin/fastcgi-mono-server2 /applications={SERVER}:/:{ROOT} /socket=tcp:127.0.0.1:{PORT} &

Restart nginx and your application should be ready at the server_name of your choice. However, manually starting up FCGI isn’t too exciting. Fortunately, there’s an awesome script written by Tomas Bosak which automates that part – follow Tomas’ instructions to install the script, but make sure to update the path to the FastCGI binary if you compiled from source.

Another option would be to use nginx to proxy requests to a standalone XSP instance: it should be fairly straightforward, but I didn’t try it at all.

Mono <3 MySQL and Fluent NHibernate

Web applications usually work with some kind of a database. There are several ADO.NET providers working with Mono for different database servers like MySQL, PosgreSQL and Microsoft SQL Server. MySQL provides the Connector/Net library, which is a fully-managed ADO.NET provider. Setting it up is easy: download the library, unzip and add a reference to mysql.data.dll in MonoDevelop. Also note you’ll have to use the DLL from the “v2/” folder. There’s a quick & dirty tutorial on the Mono project website, and in-depth documentation on the MySQL website which should have enough information to get you up & running.

If you run into a “connection refused” message while trying to connect with MySQL, take a peek in your /etc/mysql/my.cnf: you should either have an uncommented line in there saying “skip-networking”, or a directive which says “bind_address = 127.0.0.1″, depending on your MySQL version.

If you’d like to use Fluent NHibernate with Mono – good news! It works perfectly without any hacks: just download Fluent NHibernate and reference it in your project. Here’s a sample CreateSessionFactory() method for MySQL:

private static ISessionFactory CreateSessionFactory() {
    string connStr = "server=localhost;user={USER};database={DB};port={PORT};password={PWD}";
    return Fluently.Configure()
    .Database(
        MySQLConfiguration.Standard.ConnectionString()
    )
    .Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly()))
    .BuildSessionFactory();
}

Voilà.

ASP.NET MVC 3, WebMatrix, future…

Mono 2.10 should support ASP.NET MVC 3, although it’s not yet bundled with Mono as is the case with previous versions. There is also some preliminary support for WebMatrix in the form of WebMatrix.Data.dll and Razor. I didn’t have the time to play with any of these, so if you have some experience in setting it up, please share them in the comments.

I really like C# and ASP.NET MVC and I enjoy the idea of running .NET web applications on top of my preferred OS. This is something I’ll definitely be tinkering with in the future. For any questions, comments, advice or suggestions, feel free to use the comment form below, mention me on Twitter or contact me by e-mail on nikola@plejic.com.

F#: Funkcijsko programiranje za .NET (WebUG, studeni 2010.)

2010-10-19T16:37:32+02:00

18. studenoga sam na sastanku Web User Groupa održao predavanje o F#-u, višeparadigmatskom (no naglašeno funkcijskom) jeziku za CLR. Nije trivijalno strpati mali uvod u funkcijsko programiranje i cijeli novi programski jezik u ispod sat vremena, ali se nadam da sam makar dijelom u tome uspio.

Od danas su dostupni i materijali sa sastanka koji uključuju i moju prezentaciju i Visual Studio 2010 solution s primjerima. Ukoliko nemate VS2010, vrijedi napomenuti da F# kompajler bez problema radi i na Monou.

Predavanje će, u malo drugačijem izdanju, biti reprizirano na sljedećem sastanku Lang Ganga u klubu Mama koji se događa svake prve nedjelje u mjesecu.

File upload in Clojure & Compojure

2010-09-02T18:47:50+02:00

Compojure is coming to be a really nice framework which is, together with the excellent Enlive templating/transformation library, enough to make this Lisp n00b take a shot at developing a toy project or two in a Lisp dialect. I struggled a bit today to do a file upload: it’s a relatively recent feature in the framework and although it’s pretty straightforward, it took me a while to get it up to speed. Here’s a really basic and primitive example which assumes you have clojure.contrib, Ring, Compojure and Enlive installed.

The key step is to wrap your upload handling route with the wrap-multipart-params middleware from the ring.middleware.multipart-params namespace. The route responsible for the file upload is the latter one:

(defroutes public-routes
      (GET "/" [] (render (index)))
        (mp/wrap-multipart-params
            (POST "/file" {params :params} (upload-file (get params "file")))))

(file in the (get params "file") call is the name of the input field.)

Next, here’s the upload-file handler function called by the route which just takes the file and copies it to a file named file.out in the current project directory:

(defn upload-file
          [file]
                (ds/copy (file :tempfile) (ds/file-str "file.out"))
                      (render (upload-success)))

(ds is an alias for the clojure.contrib.duck-streams namespace, and render is a function which takes a template and returns its string representation. upload-success is an Enlive template.)

Voila! Not hard at all. Also check out the gist with complete code and template files.

(G)Vim: postavljanje opcija u ovisnosti o direktoriju

2010-02-25T20:58:17+01:00

Paralelni rad na nekoliko različitih projekata¹ može biti zanimljiv, ali i frustrirajuć ukoliko ti projekti koriste različite konvencije za pisanje koda. Vim spašava stvar sa svojih nekoliko načina za korištenje paralelnih konfiguracija.

Svako rješenje ima svojih prednosti, no najjednostavnijim se i najefikasnijim u mojem slučaju pokazalo dodavanje sljedeće linije u ~/.vimrc:

au BufRead,BufNewFile /path/do/foldera/* setl noexpandtab

Gornji primjer će za sve fileove koji se nalaze unutar foldera /path/do/foldera (i ispod njega) koristiti “prave” tabove umjesto spaceova koji su moja defaultna konfiguracija. Hvala, Vim.

¹ (“Paralelni rad na nekoliko različitih projekata” ujedno i vrlo dobro opisuje razloge radi kojih je ovaj blog mrtav više od pola godine.)

Zašto Wolfram|Alpha neće ubiti Google i zašto to nije bitno

2009-05-21T14:52:09+02:00

Od svog predstavljanja, Wolfram|Alpha ne prestaje privlačiti pozornost tehnološki osvještenijeg dijela populacije. Reakcije su mnoge, od izrazito pozitivnih do izrazito negativnih, a mnoge od njih pokazuju određeno nerazumijevanje koncepta same aplikacije.

Tko i što je Wolfram Research?

Prije nego što krenemo u detaljniji pogled u Alphu treba predstaviti njihove stvaraoce — Wolfram Research, na čijem čelu stoji karizmatični i ponešto kontroverzni Stephen Wolfram. Wolframovci su najpoznatiji po iznimno moćnoj Mathematici, softveru s kojim su upoznate generacije inženjera različitih struka i koji obuhvaća alate za računalnu algebru, numeričke kalkulacije, statistiku i još mnogo grana matematike, a u sebi sadrži bogatu bazu astronomskih, fizikalnih, kemijskih, lingvističkih, financijskih i inih podataka na koje se ti alati mogu primijeniti.

Zašto Alpha nije ni Google ni Wikipedija

Wolfram|Alpha je praktički Mathematica na steroidima prenesena na web, s (blago rečeno) nadopunjenom bazom kojoj se upiti šalju engleskim jezikom. Za sada sam primijetio dvije glavne zamjerke koje se protežu kroz većinu osvrta: starost podataka i nedostatak određenih informacija. Oba problema su poprilično ozbiljna ukoliko se Alpha promatra kao tražilica, od čega će Wolframovci vrlo vjerojatno teško moći pobjeći s obzirom na već stvoreni dojam i na user interface koji izrazito podsjeća na, primjerice, Google.

No, već u logotipu stoji da Alpha nije tražilica, nego computational knowledge engine*, te stoga prikuplja podatke, i to strukturirane podatke kojima zna manipulirati. To otprilike znači da imate nevjerojatno veliku bazu (10+ trilijuna redova) s kojom možete vršiti raznorazne kalkulacije. Evo nekoliko primjera (klik za veću sliku):

Iz ovog vrlo malog uzorka je vidljiva prava moć Alphe. Podaci možda nisu najaktualniji, ali aktualnost lagano pada u drugi plan jer podatke nije toliko teško aktualizirati koliko je teško razviti ovakve alate za manipulaciju. Upravo tu leži glavna razlika između Alphe i svega ostaloga: ostali mogu imati najaktualnije podatke na svijetu, ali s njima ne mogu ništa, osim ih prikazati krajnjem korisniku. (Disclaimer: Google navodno radi na svom odgovoru, Google Squaredu, ali o tome ćemo kad to vidimo.)

Koga briga?

Iako mnogo ljudi koristi tražilice i enciklopedije, mali broj njih zapravo želi raditi kompleksne matematičke manipulacije podacima na koje naiđu. No, Wolfram Alpha može poslužiti mnogo širem krugu ljudi od znanstvenika:

s obzirom na bogatu bazu matematičkih funkcija i podataka iz prirodnih i društvenih znanosti, može pomoći osnovnoškolcima i srednjoškolcima u lakšem razumijevanju gradiva,
izrazito pojednostavljuje istraživanje (ne samo znanstveno, nego i istraživanje za članak na vašem blogu) s obzirom da stavlja fokus na podatak, što izrazito povećava omjer signala i šuma,
olakšava stavljanje podataka u kontekst jednostavnim manipulacijama (npr. omjerima),
igranje podacima može biti zabavno :).

Ni Wolfram nije savršen…

Da ne bi sve ostalo na pohvalama, Wolfram ima još puno posla. Neki relativno jednostavni upiti još ne rade, a iako je zadavanje upita na engleskom odličan feature koji funkcionira dosta dobro, osobno bih volio vidjeti i neki egzaktniji način izvlačenja podataka iz baze (primjera radi, Population[New York] umjesto “population of new york”). API je za sada ograničen i ne postoji neka detaljnija dokumentacija niti primjer izrade aplikacija koje bi se bazirale na Alphi.

No uz sve to, smatram da će ovakvi servisi uvelike olakšati život ljudima koji traže i obrađuju informacije. Ne, Alpha neće ubiti Google jer vam neće reći kako implementirati binarno stablo u C-u, niti će ubiti Wikipediju jer vam neće objasniti zašto je došlo do trenutnog teritorijalnog spora Hrvatske i Slovenije, ali neće biti ni obrnuto jer trenutno aktualni web servisi nisu svjesni podataka kojima raspolažu koliko je to Alpha.

Creative Commons knjige o informatici i programiranju

2008-08-18T20:05:24+02:00

Na internetu je moguće pronaći mnoštvo tutoriala o širokom spektru tema iz informatike, no rijetko što može zamijeniti dobru knjigu. S druge strane, knjige mogu biti (pre)skupe i vrlo teško dostupne, pogotovo ako nemate luksuz posjedovanja kreditne kartice za online kupovinu.

Zahvaljujući dobroj volji autora (i izdavača), neke su od knjiga koje se smatraju klasicima literature iz područja informatike i programiranja dostupne besplatno, a ponekad i pod vrlo liberalnim licencama. Donosim tri takve: dvije hardcore programerske i jednu pravno-filozofsku.

Abelson & Sussman: Structure and Interpretation of Computer Programs

Tzv. wizard book (po čarobnjaku na naslovnoj stranici) je definitivno jedan od the udžbenika iz programiranja po kojemu su uvodne kolegije iz programiranja učile generacije na MIT-ju. Koristeći Scheme (dijalekt Lispa), objašnjava temeljne koncepte iz računalnih znanosti, npr. apstrakciju i rekurziju.

U jednom od prethodnih linkdumpova sam objavio i link na video zapise Abelsonovih i Sussmanovih predavanja koja, nažalost, slijede prvo izdanje knjige. Autori napominju da će predavanja biti korisna i vlasnicima drugog izdanja.

Knjiga je objavljena pod Creative Commons Attribution-Noncommercial 3.0 licencom, čime je dopušteno nesmetano modificiranje i distribuiranje rada za nekomercijalnu uporabu, uz navođenje izvornih autora.

Leo Brodie: Thinking Forth

Još jedna knjiga koja se smatra klasikom—možda u manjoj mjeri od prethodne, što vjerojatno duguje opskurnijem jeziku za kojeg je napisana. No, principi koje objašnjava su univerzalni i neki od njih su nedavno ponovno otkriveni u tzv. eXtreme Programming paradigmi.

Podnaslov knjige je A Language and Philosophy for Solving Problems, i bavi se upravo time—dizajnom, analizom i implementacijom rješenja problema. Uz smiješne ilustracije i puno humora, vrlo detaljno opisuje razvoj programa, ali i neke stvari koje se u ovakvoj knjizi ne očekuju, npr. odnos s klijentima.

Knjiga je skenirana, OCR-ana, obrađena u LaTeXu i objavljena pod Creative Commons Attribution-Noncommercial-Share Alike 2.0 licencom.

Lawrence Lessig: Free Culture

Iako nije direktno povezana s programiranjem, s informatikom definitivno jest. Lawrence Lessig je jedan od osnivača Creative Commonsa, organizacije koja je ‘izmislila’ licence pod kojima su gore navedene knjige izdane.

U ovoj se knjizi Lessig bavi copyrightom, intelektualnim vlasništvom i ostalim stvarima za koje nas ‘digitalno doba’ tjera na razmišljanje i redefiniranje. Dostupna je pod Creative Commons Attribution-Noncommercial 1.0 licencom.

Ove tri knjige bi vas u svakom slučaju trebale držati zauzetim neko vrijeme. Ukoliko sam propustio neku vrijednu spomena, svakako mi javite u komentarima.

Zašto neki developeri misle da su pametniji od drugih

2008-07-31T10:01:22+02:00

Relativno sam nedavno na Redditu pronašao interesantan dokument pod nazivom Programmer Competency Matrix. Par dana nakon toga sam se ponovno sjetio dotičnog i – zaboravivši link – krenuo u potragu na Googleu. Usput sam naletio na nekoliko članaka na blogovima koji komentiraju tablicu, od kojih mi je jedan posebno zapeo za oko.

Autor, naime, opravdava svoj nezadovoljavajući uspjeh na “testu” činjenicom da je on web developer, dok je tablica dizajnirana za čiste programere. Ne ulazeći u semantiku pojma “čisti programer” (koja mi nikako nije jasna), stav članka me izrazito iznenadio. Imam osjećaj kao da autor smatra da je njegovo neznanje sasvim prirodno i opravdano samo zato jer se on bavi – webom.

Zadnji put kad sam ja provjeravao, svi smo mi pisali programe. I web i offline aplikacije ovise o gotovo identičnim resursima – obje koriste CPU vrijeme, memoriju i prostor na disku. I u web aplikacijama se podaci mogu provlačiti kroz kompleksne algoritme kod kojih je itekako bitna potrošnja tih resursa.

Svakako, neke od stvari navedenih u tablici nisu neophodne prosječnom web developeru. Čemu onda sve to? Dublje (teorijsko) poznavanje područja kojim se bavite nerijetko nagrađuje mnogim stvarima koje možete primijeniti u praksi i razumijevanjem stvari koje već primjenjujete. Uostalom, Joel je o potrebi poznavanja low-level stvari pisao već nekoliko puta i sve to objasnio puno bolje od mene.

U proteklih tjedan-dva sam pročitao nekoliko članaka u kojima se na web development gleda s visoka, kao na manje vrijedan dio programiranja (link samo na jedan jer sam ostale zaboravio bookmarkirati – tko prati Reddit i DZone će se sigurno sjetiti još pokojeg). Stavovi slični onima u gore navedenom postu autorima tih članaka sigurno nisu odmogli u formiranju takvog mišljenja.

Open source softver za matematiku i prirodne znanosti

2008-07-22T12:00:07+02:00

Svatko tko se ikada imalo intenzivnije bavio prirodnim znanostima čiji je jezik sporazumijevanja matematika, morao se upoznati s jednom od mnogobrojnih programskih paketa za numeričku ili simboličku kalkulaciju.

Mathematica, MATLAB i Origin su neki od najpopularnijih, no iako su to odlične aplikacije, mnoge će vrlo brzo odbiti njihova cijena. Naime, samo studentska licenca za Wolframovu Mathematicu košta 80 funti (blizu 800 kn), dok je MATLAB za studentski džep nešto jeftiniji – 99 dolara (oko 450 kn).

Neki fakulteti nude svojim studentima besplatne licence za neke od navedenih aplikacija. Problemi nastaju ukoliko niste na jednom od tih fakulteta i/ili se time bavite čisto rekreativno – u tom slučaju vam cijene mogu ubiti početni entuzijazam i natjerati vas da se odete baviti mrvicu isplativijim hobijem.

No, nije sve tako crno. Budući da je open source softver vrlo raširen u znanosti (zapravo, tamo je sve i počelo), bilo bi neobično da ne postoje besplatne, otvorene alternative koje će biti i više nego dovoljne prosječnom studentu i entuzijastu, a sigurno će zadovoljiti i potrebe nekih od zahtjevnijih korisnika.

Navedeni softver ne moraju nužno koristiti samo doktori matematike. Iako većina softvera iz ove kategorije neće dobiti nagradu za najintuitivniju aplikaciju s korisničke strane, uz malo podešavanja i truda može odlično poslužiti i srednjoškolcima i osnovnoškolcima pri savladavanju nekih matematičkih koncepata i često zaboravljenog i zanemarenog “igranja” s matematikom.

GNU Octave

Konkurira: FORTRAN-u, MATLAB-u
Licenca: GNU GPL

GNU Octave je programski jezik prvenstveno namijenjen numeričkom računanju. Donekle je kompatibilan s MATLAB-om, a kompatibilnost se – navodno – iz verzije u verziju poboljšava.

About stranica navodi da Octave ima alate za rješavanje problema iz linearne algebre, nalaženje korijena nelinearnih jednadžbi, rad s polinomima i integraciju običnih funkcija i običnih diferencijalnih jednadžbi, među ostalim.

Octave je nastao kao reakcija na FORTRAN, kao prateći softver udžbenika za kemijski inžinjering. Ukoliko ste upoznati s MATLAB-om, jezik vam ne bi trebao biti problem, a ukoliko niste, odličan (iako nedovršen) tutorial se nalazi ovdje. Octave je trenutno u verziji 3.0.1 i dostupan je za download sa službene stranice projekta.

gnuplot

Licenca: source kod je dostupan, ali redistribucija modificiranih verzija nije dopuštena

Gnuplot je besplatni alat za dvodimenzionalno ili trodimenzionalno plotanje (pametni izraz za “crtanje”) podataka i funkcija. Podržava mnoštvo formata za output, među kojima i znanstvenicima omiljeni LaTeX. Vrlo je moćan, a može se koristiti i u sklopu Octavea, kao engine za plotanje.

Iako ima “gnu” u imenu, gnuplot nema veze s “onim” GNU-om, i licenca mu ne dopušta redistribuciju modificirane verzije programa. Trenutno je u verziji 4.2 i može se naći na službenim stranicama.

Axiom

Konkurira: Mathematici
Licenca: Modificirana BSD licenca

Ovo je vjerojatno najkompleksniji i najstariji ovdje predstavljeni projekt. Razvoj je započet 1973. u IBM-u, a od tada je bio pod raznim tvrtkama. Danas ga održava Tim Daly, bivši glavni developer projekta.

Axiom je CAS (Computer Algebra System) s interaktivnim okruženjem, vlastitim programskim jezikom i velikim skupom libraryja za numeričke, simboličke i algebarske proračune.

Najbolje mjesto za informacije je wiki na kojem možete interaktivno koristiti Axiom (zajedno s drugim softverom kao što je Sage, Maxima i sl.) bez potrebe za instalacijom na vlastito računalo.

Geogebra

Licenca: GNU GPL

Ukoliko vam je sve ovo prekomplicirano, tu je Geogebra. Mali, jednostavan, ali moćan program napisan u Javi namijenjen je prvenstveno školama (osnovnim i srednjim). Najviše je fokusiran na geometriju, ali može i derivirati i integrirati neke funkcije.

Geogebra je odlično dokumentirana i dovoljno je jednostavna da se može (i trebala bi se) naći u svakoj učionici na satovima matematike za lakše i brže razumijevanje gradiva, pogotovo trigonometrijskih funkcija, derivacija i integrala.

Trenutno je u verziji 3 i dostupna je za download sa službene stranice.

Ima toga još!

Na Ubuntu wikiju postoji odjeljak UbuntuScience gdje možete pronaći još mnogo vezanih aplikacija s linkovima na njihove stranice. Bez brige, iako se radi o Ubuntu wikiju, većina navedenog softvera radi i na drugim platformama.

Programiranje i informatika – Je li fakultet potreban?

2008-07-01T14:40:26+02:00

U posljednje vrijeme po raznim forumima relativno često naletim na thread gdje mladi (budući) developeri razmišljaju o odabiru srednje škole ili fakulteta. S obzirom da nerijetko dobivam takva pitanja od svojih poznanika, a u sličnoj situaciji sam nedavno bio i sam, imao sam prilike dugo i intenzivno razmišljati o toj temi. Prosječan razgovor s dotičnom žrtvom sada izgleda nekako ovako.

Želite li programirati?

Prvo što savjetujem svima je da dobro razmisle je li programiranje nešto s čime se žele baviti do kraja života. Programiranje može biti vrlo zabavno, no pojam zabave jednog četrnaestogodišnjaka i dvadesetpetogodišnjaka zasigurno nije identičan.

Naravno, očekivati od osnovnoškolca (pa čak i ponekog maturanta) da pokuša zamisliti bi li ga/ju dotični posao ispunjavao u srednjim godinama je nerealno, ali svatko s malo iskustva u ovom području mu/joj može dati okvirnu sliku nekakvog prosječnog posla u IT sektoru.

Fakultet možda nije bitan, ali…

Nadalje, naglasim da formalno obrazovanje u ovom području ljudske djelatnosti na kraju krajeva i nije toliko bitno. Profil ljudi koje sam imao prilike upoznati, a koji se profesionalno bave webom i programiranjem općenito je impresivno raznolik: tu ima sociologa, matematičara, fizičara, fitness trenera, filozofa, informatologa, elektrotehničara (visokog i srednjeg stupnja obrazovanja), ekonoma…

U biti, puno je lakše navesti struke koje nisam susreo tijekom proteklih nekoliko godina – veterinari mi prvi padaju napamet, ali sam siguran da ćete me ubrzo razuvjeriti.

Nakon početnog šoka “pa u biti taj fakultet ti baš i nije tol’ko bitan” stavom, ravnotežu u svemiru održi činjenica da je, bez obzira na faks, potrebno uložiti puno (ovo obično izrazito naglasim i popratim grotesknim gestama čime pokušavam naglasiti koliko je puno to “puno”) ex privata diligentia rada na vlastitom skupu vještina koji, naravno, ovisi u području u koje se predmet ove rasprave želi usmjeriti (web, desktop, znanost…).

Hrvatski fakulteti za programere

Oni koji prežive do ovog trenutka i ustraju u razgovoru, ovdje obično zahtijevaju neku konačnu preporuku srednje škole ili fakulteta, unatoč mom silnom trudu da konačni odgovor izbjegnem i “brigo moja prijeđi na drugoga” metodom taj savjet prepustim nekome drugom.

Što se srednje škole tiče, tu obično preporučim neku gimnaziju – ne nužno prirodoslovno-matematičku, iako ta jest najprirodnije usmjerenje u ovom slučaju. Gimnazija, koliko god nepraktična bila, ipak koliko-toliko drži ljude podalje od nekog fah-idiotizma i fah-elitizma, a nudi dovoljno prostora za manevriranje i ako se početno usmjerenje promaši.

Moj izbor fakulteta je sljedeći, i to ovim redoslijedom:

Matematika i računarstvo na Matematičkom odjelu Prirodoslovno-matematičkog fakulteta u Zagrebu
Računarstvo na Fakultetu elektrotehnike i računarstva u Zagrebu (kroz neki od ponuđenih profila)
Informacijsko i programsko inženjerstvo na Fakultetu organizacije i informatike u Varaždinu
Informatika na Tehničkom veleučilištu u Zagrebu

N.B. da su svi gornji studiji, izuzev zadnjeg, diplomski (onih +2 u 3+2 “bolonjskom” sustavu). Prijedlozi pod brojevima 2, 3 i 4 su poprilično očiti i vjerujem da ih ne treba dodatno pojašnjavati. To je ono što otprilike svatko tko dođe po savjet želi čuti, i ono što sam zna.

Na prvi navedeni prijedlog se većina zgnuša, ili ga šutke zanemari. No, nakon dvije godine na PMF-u (doduše, na drugom odsjeku) smatram da je to fakultet koji može oblikovati stvarno kvalitetnog developera.

Program na Matematičkom odsjeku mi se čini jako kvalitetnim, a stečeno znanje matematike je nešto što se nikako ne smije podcijeniti. Također, matematika je osnova svih informacijskih znanosti i poznavanje te (subjektivno, predivne) znanosti osobi koja se planira baviti programiranjem nikako neće biti na odmet.

Koju srednju školu / fakultet odabrati?

Odabir dobre srednje škole i fakulteta je svakako nešto što budućem developeru može pomoći, no nikako nije presudno. U zadnje vrijeme sam svjedok sve većem broju ljudi koji su inače jako dobri u ovom području, a biraju srednje škole i fakultete koji nisu nužno vezani uz informatiku.

Razloga je mnogo – neki od njih stvarno žele graditi karijeru u nekom drugom području, neke izrazito zanima “taj drugi” fakultet i smatraju da i uz to mogu ostati konkurentni kao developeri, neki žele imati plan B u slučaju da im se ovaj posao zgadi, propadne i sl.

Iz moje perspektive, to nikako nije loša praksa. Činjenica je da, i uz fakultet vezan uz informacijske znanosti, treba mnogo raditi na vlastitom skillsetu; ja još čekam na obrazovnu ustanovu koja će osobu pripremiti na situacije s kojima se prosječan developer svakodnevno susreće u “stvarnom svijetu”.

Iz komentara

Komentatori su mi skrenuli pozornost na dva članka koja se bave sličnom problematikom. Jedan je članak Berislava Lopca, pod nazivom Kodiranje i obrazovanje, a drugi Tonija Aničića Koji fakultet / školu / tečaj da završim ako želim raditi web stranice?. Oba su popraćena interesantnim raspravama koje svakako vrijedi pročitati.

Ukoliko vas programiranje toliko ne zanima i više ste marketinški tip, Mario Frančešević donosi pregled vještina koje osoba koja se planira baviti internet marketingom. Mario je u komentarima također poslao link na interesantan članak iz Wall Street Journala pod nazivom For Most People, College Is a Waste of Time.

Također, u komentarima možete pročitati i iskustva nekih ljudi koji su kroz fakultet (ili njegov nedostatak) već prošli, pa skoknite do tamo, pročitajte što kažu i pridružite se raspravi.