kiiski

Or alternatively click on the start point, hold shift and click on the end point.

> place where the sun doesn't shine in winter

For at least one day a year. Not the whole winter.

Here isn't Nokia anymore. They sold it to Audi, BMW and Daimler in 2015.

I was a member about 5 years ago. I also left the club soon, but my experience was pretty different from yours. I never went to the "official" meetings, but I did go to two of the "Mensa youth" (I was around 20, others there seemed to be 25-35) weekend gatherings in the countryside.

The gender ratio was around 60/40 men/women. I don't think anyone even mentioned the term "IQ". It was mostly like a student group outing with people drinking, talking, playing board games, going to sauna (this was in Finland), swimming, flying around in a inflatable boat someone had converted to an ultralight floatplane and such.

Regarding 1. Emacs does have keyboard macros. A bit more involved than just hitting dot, but they do let you compose an arbitrary sequence of operations (including selection) that can be repeated or saved and applied later.

What kind of workflow do you mean? Simply taking a screenshot and inserting a link to it would be pretty easy, at least in Emacs

  ;; There probably are better solutions already 
  ;; available somewhere.
  (defun org-insert-screenshot (filename)
    (interactive "sFilename: ")
    (let ((filename (concat filename ".png")))
      ;; import is from ImageMagick, change to whatever you like to use
      (call-process "import" nil nil nil filename)
      (insert (format "[[file:%s]]" filename))
      (org-display-inline-images)))

Wikipedia claims that "In 1950, New York City was the only urban area with a population of over 10 million."

https://en.wikipedia.org/wiki/Megacity#Growth

> But then she's upset

To be fair, from her point of view your hours playing Civilization might not balance out her having dinner alone.

I'm not familiar with the details of Norway, but the Nordic countries have so called "everyman's rights" which among other things say that owners of forests can't restrict people from roaming in their (uncultivated) land. Building a fence around your forest would most likely not be allowed.

District heating[1] has been around for a long time. At least here in Finland most people in cities use it.

[1]: https://en.wikipedia.org/wiki/District_heat

> I can't talk about Finland

Here's a map for the carrier in question: https://elisa.fi/kuuluvuus/

One could also use Emacs (in a graphical window rather than in the terminal) `woman` and `variable-pitch-mode`.

It's very unlikely that he is there to actually guard anything. In most countries, outside a state of emergency or war, soldiers do not have any right to shoot citizens in the streets. Even if someone specifically attacks the soldier, the correct response is to back away and call the police to handle it.

He's just standing there either for ceremonial reasons or for training (possibly both). In any case, his only task is to stand there and call the police if there's trouble.

Edit (re: reply by dagss): I seem to have misunderstood the comment, but can't delete anymore.

What do you mean with "macro code injection vulnerabilities"? Macros are expanded before the code is compiled; by the time someone is running the program there are no macros. Well, technically, someone could call `EVAL` in a production app, but that's strongly discouraged.

> Spacemacs takes so long to load that it's laughable.

Emacs is typically started once, and then you open files in the same instance. With vanilla emacs you can use `emacs --daemon` to start it as a server, and then use `emacsclient` to open files. That way it should open pretty much instantly. I'm not sure what Spacemacs calls those.

In the regular speedbar you can hit `b` to see a list of buffers. I imagine it works with sr-speedbar too.

I just went to my local S-Market and looked around a bit. The big soft drink bottles were all 1.5L (as noinsight said). Milk is available in 1.5L cartons too, but no plastic bottles of any kind. Of course, I do live in a pretty remote corner of the country, so maybe the selection isn't what it is in Helsinki.

Sure, now that people mentioned them. That's why I said "can't associate .... of the top of my head". But that's not the point. The parent implied that there is something that's 2 liters that all Americans know, and I was curious as to what that is, because I, despite living in a metric country, couldn't think of anything.

The 2L soft drinks are probably available, but I just never buy any of them. Milk, juice and yoghurt come in one liter packages.

Why is that? I'm just curious, because I (finnish) can't associate two liters with anything of the top of my head. Everything is always one liter.

Also worth noting that that huge army they have consists of conscripts (6-12 months of service), led by officers that are now selected by religion+loyalty to Erdogan rather than skill. Not exactly the kind of army you want to conquer the world with.

I think the idea is that the macro expands into an efficient template. Instead of having to always build the same constant strings for every request, you can expand into a bunch of WRITE-STRINGs, with the dynamic parts in between.

There is one for Common Lisp too https://github.com/m2ym/optima

The basic idea is to have a uniform way of setting values to variables or calling a setter method. That's very helpful for writing macros that need to both read and set a value.

For example, the `+=`-operator found in many languages is implemented as a macro in CL (INCF). It needs to read the value of a place, increment it and then set the new value to the same place.

Doing that with a variable is easy. Using non-lisp syntax

  x += 5 

expands to

  x = x + 5

Doing that with object slots is easy too, if you don't mind accessing the slot directly. However, if you want to have getter and setter methods (which may not even correspond directly to a slot in the object) the expansion would look different.

  o.setFoo(o.getFoo() + 5)

or if the getter and setter can have the same name

  o.foo(o.foo() + 5)

Since the expansion is different, the macro would have to figure out whether it's dealing with a variable or an accessor method and behave differently. With generalized references you can use the accessor method as if it was a variable

  o.foo()      // calls the getter
  o.foo() = 5  // calls the setter

Now you easily can expand

  o.foo() += 5

to

  o.foo() = o.foo() + 5

just the same as you would with a variable. Behind the scenes you still have separate getter and setter methods, but the macro doesn't need to worry about that.

It doesn't search HN, rather it redirects you to the search at hn.algolia.com. The same works for many other sites. So for example "foo doesn't work !so" redirects to Stack Overflow search for "foo doesn't work" and "Foo !wfi" redirects to Finnish Wikipedia search for "Foo".

> It's also was never a part of the 3 monarchies of Scandinavia until the more modern use of Scandinavia for tourism.

Finland was a part of Sweden from ~1200 to 1809. Finland also still has a large Swedish minority and has Swedish as an official language. The biggest religion is Lutheran due to Swedes forcing it on people when they conquered the land. Estonia is more Orthodox.

More importantly, Finland has been co-operating with the other Nordic nations politically and economically for the ~century that it has been independent. Remember that the Nordic nations aren't just a cultural region, but they also share political, social and legal systems, have a passport union (although that overlaps with the EU nowadays) and, while they have not been able to develop any official military alliance due to Russian and American pressure, they co-operate a lot.

All in all, Estonia has some things in common with Finland, but it doesn't have much claim to being a "Nordic nation". They might be in the future, but not today.

And SSH, MySQL.

Adding to this, in a real situation those variables are probably not going to be nice single letter variables. With longer names the Lisp syntax with unambiguous structure/order of precedence becomes much nicer.

  (if (or (and foobar
               (some-predicate-p quux)
               (= qwerty 432))
          (a-long-function-call-with-two-args bar ytr))
      ...)

Compared to something like:

  if (foobar &&
      somePredicate(quux) &&
      (qwerty == 432) ||
      aLongFunctionCallWithTwoArgs(bar, ytr)) {
      ...
  }

Your example is also misleading. The `a` and `expr` are written as variables in the left example, but as function calls in the Lisp version. More correctly it would be either

  if (a && !b) { expr } => (if (and a (not b)) expr)

Or

  if (a() && !b) { expr() } => (if (and (a) (not b)) (expr))

Now the amount of parentheses is either 4/6 or 8/10 which is not a very big difference (and caused only by the syntactic sugar for `not`), especially considering that the left example uses `!`, `&&` and two kinds of parentheses (perhaps a `;` as well).