phoenix's hideout

This is a spot for things I consider interesting.

[phoe-krk]

Openmailbox 2.0: new owner, outages, brokenness, paywalled and removed features

The Context

For the past two days, Openmailbox was unavailable, doing some kind of upgrade. Nobody was notified of that upgrade taking place or of the fact that there would be a complete outage of that mail provider's services: mail and cloud storage.

It came back today, with a refreshed interface:

Uh, actually, not that one. (That's what has been happening with OMB for at least three months, but that's not what I'd like to talk about in this post.)

The Reason

Openmailbox changed hands, and us - its users - were not informed of that fact.

Compare the legal data of the previous owner with the legal data of the new owner. Screenshots here for goodness's sake:

The Pros

The new webmail interface looks rather nice. It is pleasant to have the cloud storage and mail integrated in one place.

It seems that the total available storage for a free account was boosted to 5 GB in total. This seems to be shared between the mail and the cloud storage, though I've had about a gigabyte of mails and the system currently does not take this into account. Likely to be a serverside error, IMO.

The Cons

IMAP/SMTP/POP3 access became paywalled. This means that me - a heavy Thunderbird user - was left out without a way to use my favorite mail client.

Mail aliases completely disappeared. This means that the old aliases *@openaliasbox.org just disappeared overnight and no longer redirect any messages.

The webmail app is broken - it is impossible to send emails. With IMAP locked out, this means that OMB mail is right now read-only.

There was zero communication of this ahead of time. The users were not informed of the outage nor of the upgrade's consequences and woke up to the fact their functionality is restricted.

The Shitstorm

Openmailbox was a provider that was very popular with the Linux community. The changes they have made have sprung some reaction from people who, until now, had no reason to think they would be betrayed by OMB like that. Some of that reaction was rather emotional

Probably the most flames are happening on OMB's Twitter right now, though Reddit has also seen the outrage. This last link contains a quickly created Python tool for backing up mail from OMB through their new web UI - not everyone was as lucky as I was to have enabled a local mirror of all OMB mail.

The Outcome

Above, I've used the word "betrayed" - and that's exactly how I am feeling right now. OMB went against their users and disabled the features that made it good and worthwhile for me in the first place and, from the Internet's response, it looks like I am not alone.

Their argumentation, as seen on Twitter, is: maintaining IMAP/POP3 is "expensive". From what I saw - OMB had all the money it needed. The donations that were requested by OMB were fulfilled; if the costs stated publicly were real, then OMB had enough funds to go on with their previous configuration.

The Alternatives

Teknik.io offers free email along with utilities like pastebin, Mumble, unlimited Git repositories (with Gitea as the web UI) and a blog - including the blog you're reading this on right now. UPDATE: Since teknik.io had an outage, I temporarily posted this blog post on tumblr instead.

Disroot is a little-known free service that bundles multiple tools: mailserver, ownCloud, Diaspora, Discourse, Lufi, Taiga, Etherpad et al.

As long as you're not scared of 4chan and putting your mail in the private hands of a single person*, it seems that cock.li is a viable mail alternative. Among their collection of very 4chan-like domains, they have this pretty nice and innocent @airmail.cc domain name.

*come to think of it, though, isn't it less scary than putting your data into the hand of some corporation that'll use it for whatever it wants? it all comes to trust in the end.

tl;dr

OMB was bought over and decided to suck, I'm jumping ships.

[phoe-krk]

A small note about Git

These two months I've spent doing some real hardcore programming *do* have a huge impact on my workflow. Mostly because of Git. It *is* mindset-changing. Before, I'd never have dreamed of just downloading a repository, making some changes to it and pushing it back upstream for a pull request. Now, it's half an hour of clicking and searching and I have a feature ready to be integrated into mainstream. https://github.com/sionescu/bordeaux-threads/pull/22

[phoe-krk]

So I write a small report containing my personal highlights about the 9th European Lisp Symposium. Enjoy!

[phoe-krk]

19:17 Hi - I think I need to use: (eval-when (:load-toplevel) ...) when compiling Clasp. Fare says this is bogus (http://fare.livejournal.com/146698.html).

~ the lisp channel on Freenode

I've read the very same text a few hours before, so I decided to respond straight away; the text below is a slightly rewritten and widened response from #lisp.

drmeister: with all due respect to Fare, I think he simply didn't think of a case such as yours. You're basically a Lisp implementer and, from my perception, EVAL-WHEN was meant to be a tool for people like you, poking their nose deep into Lisp's bowels. Let me explain why.

A very average programmer will never poke their way into how Lisp works. They'll just write their algorithms, do their I/O, and be happy with the simple macros that are AND, WITH-OPEN-FILE or similar. They won't ever need to go into the weirdnesses of EVAL-WHEN.

An average Lisper will write their own macros that abstract syntax away. But they won't really metaprogram with them; they'll be happy that they won't need to type a bunch of SETF/ASSERT lines in each function. They won't ever need to poke into EVAL-WHEN either way.

And there's the passing point, where you actually begin utilizing Lisp to alter and filter the way Lisp reads, compiles, evaluates Lisp. Turning the language on to itself. You stop programming the outside world. You start programming the inner world. You start tinkering with the order, way, selectivity of how Lisp loads, compiles, runs its parts. You start playing with how Lisp behaves and define the new meanings for how to actually code. You end up developing a new implementation of the language, carving yet another road to the top of the mountain. You start programming the language itself. You start programming the programming itself. You begin twisting and playing with the definitions of programming people host inside their heads by showing how it can be done differently blowing a few minds in the process and making them go, how could we have done it any other way before? or something similar. You might somehow end up on a completely different mountain than you were hiking.

To the mundane people like me, beyond that point I've mentioned up above, it's already dragons.

So if you venture there and actually come back alive, please document it all for the sake of humanity so we have legends to keep us hopeful and knowledge to allow us make that hope come true.

And so there's less dragons ahead.

[phoe-krk]

A tiny Parenscript snippet

(defpsmacro defdefine (dependencies arguments &body body) `(define (array ,@dependencies) (lambda ,arguments ,@body)))

[phoe-krk]

The programming language playing field has a lot of star players, and some, well, these days not so much.

With Clojure still on the rise, Scheme still being adopted by people like Carmack and Common Lisp being utilized on both brand new implementations like Clasp and constantly maintained and upgraded implementations like ECL, CCL, SBCL - I say you're simply wrong about putting Lisp on this list.

Additionally, comparing Lisp to a bunch of parentheses scattered over people's code doesn't change the above fact; it only shows that you haven't really researched the field and don't really know what Lisp is, and therefore, are ignorant and misinformed about the topic.

Please actually pay some attention to what you're writing, because, in this case, it shows you haven't, and simply are passing on some common myths and urban legends. You might say something doesn't exist based solely on what you see, but that's only your point of view - not a fact.

Oh, and yeah, the necessary "Lisp wasn't used anywhere outside the AI" list.

CANDO, the in-development language used for creating nanomaterials.

SPIKE, the scheduler for Hubble Telescope.

Remote Agent in Deep Space One.

Dynamic Analysis and Replanning Tool for the US military.

Game Oriented Assembly Lisp, a compiled language used in Naughty Dog's games.

Maxima and Axiom algebra systems.

A whole bunch of contemporary tools and frameworks for tools like web design, networking, concurrency, database access, numerical computations.

Oh, one more thing. Did Java finally get the simple stuff like a read-eval-print-loop in the standard, or do we need to wait another 57 years* for it to happen?

*Lisp's almost 58 years old, actually

This is a repost of a comment from the post linked in the comment. I deemed it appropriate to be turned into an actual blogpost.

[phoe-krk]

1 points and 1 comments so far on reddit

shameless self promotion time

[phoe-krk]

Rust features in Common Lisp - ideas

This appeared today on ##rust@freenode and it consists of a lot of my ideas that appeared when reading http://designisrefactoring.com/2016/04/01/rust-via-its-core-values/ .

< phoe_krk> steveklabnik: I'm a Lisper actually and stumbled upon that post and read it. It's fairly fascinating.

< phoe_krk> I mean- That other post.

< phoe_krk> http://designisrefactoring.com/2016/04/01/rust-via-its-core-values/

< phoe_krk> (Which is why the first question from Quora made me sad inside, but I digress)

< steveklabnik> ah :)

< steveklabnik> it was a good post

< phoe_krk> So I began wondering how to bend Common Lisp in Rust's direction and I got some interesting thoughts.

< phoe_krk> The easiest thing to do is explicit mutability in variables' declaration. I think I could fairly easily prototype a Lisp package that throws errors at you whenever you try to compile anything that attempts to mutate a variable not called mutable. (Of course, given I have the time and strength, and these two are rare and precious.)

< phoe_krk> GC would require writing or adapting a garbage collector that acts in real time; so far I've heard only of one such prototype on a single CL implementation, but it's already working.

< phoe_krk> Ownership sounds fairly simple in concept as you can modify the assignment operator to suit your needs - and modify the original reference to err out on people wherever necessary.

< phoe_krk> Borrowing is fairly trivial once you have ownership and exclusive mutability. Make a new variable, let it point to the same data, declare it immutable because it's a borrower.

< mbrubeck> Note that in Rust, ownership is purely a compile-time thing. Sounds like you're thinking much more dynamic (which makes sense for CL, but it may not give the same advantages).

< phoe_krk> Functions grabbing ownership when being called. This is doable, we can modify the way we define functions so it takes that into account.

< phoe_krk> mbrubeck: yes, I'm thinking dynamic and I'm aware of it. I'll explain why in a moment.

< mbrubeck> e.g. Rust doesn't need to add any runtime checks for "has this thing been moved?"

< phoe_krk> mbrubeck: it's a mindset difference, basically. :P

< phoe_krk> What I'm thinking is: how to aid the programmer.

< phoe_krk> And things like the ones I've mentioned are mostly about it.

< phoe_krk> Aside from GC, which sounds like the only exception.

< mbrubeck> yeah, makes sense

< phoe_krk> So basically, Lisp programming differs in concept as Lisp is image-based.

< phoe_krk> It's compiled, but the whole language is available and in memory all the time.

< phoe_krk> How does Rust check ownership? It has to compare something to something and err out if it has a wrong value.

< phoe_krk> And it has to do it at compile-time.

< mbrubeck> phoe_krk: The compiler does control flow analysis to see when something is moved.

< phoe_krk> mbrubeck: I see. So the compiler actually analyzes the *whole* code at compile-time.

< mbrubeck> phoe_krk: And it refuses to compile something that accesses a moved variable.

< phoe_krk> And at run-time, there's no checks, since everything was checked at compile-time.

< phoe_krk> Did I get it right?

< mbrubeck> Right. There are some caveats/complications; for example you can use the RefCell type to basically opt out of the static checking and use dynamic checks for safety, for example

< phoe_krk> So basically there are two steps to compilation in Rust.

< phoe_krk> 1) Assert everything is fine

< phoe_krk> 2) Compile

< phoe_krk> Right?

< steveklabnik> that's true for any kind of compiler that does static anything :)_

< steveklabnik> like, step 1 is 'type checking' in many languages

< mbrubeck> Lots of phases, in fact :) type-checking, region-checking, borrow-checking, drop-checking...

< phoe_krk> Yes, yes, but they *all* can be summed up by that. :P

< phoe_krk> And I meant mostly features unique to Rust by that.

< mbrubeck> Yes, you could consider all the "checking" to be various kinds of type checking

< phoe_krk> Such as the aforementioned borrowing, immutability and so on.

< phoe_krk> Over on the Lisp side, we have DEFUN, which is a macro that expands to a lot of other things. One of the effects is: we can either redefine it to add functionality, or wrap it in another macro that is fed the source code of the function we define.

< phoe_krk> Which means that one (e.g. I) can write a code walker that analyzes e.g. the variables we declare, looks for any keywords declaring mutability, and make a compile-time list of the mutable variables.

< phoe_krk> Then just compile. At compile-time we can run Lisp code; it means that when we "overload" the assignment "operators" to also check whether the variable in question is mutable, we can "just" compile.

< phoe_krk> The compile-time assertion disappears and we're left with a compiled, working function.

< phoe_krk> Unless our variable is declared immutable - at which point we have a nice compile-time error we can define on our own, too.

< phoe_krk> About ownership - it's the same thing, I think. A (much more complicated) code walker can traverse the code and do two things; wherever it sees assignment, change the owner of the code; whenever it sees a thing like Rust's & operator, it can strip the code of the operator and continue.

< phoe_krk> So in one case it creates a variable and changes the owner, in the other, it creates an immutable variable and doesn't change the owner.

< phoe_krk> I assume that "let mut a = &b;" is illegal in Rust?

< steveklabnik> it's not

< phoe_krk> I see.

< steveklabnik> it means the binding is mutable, but the refernece isn't

< phoe_krk> Yes - I got it. Fairly sane, too.

< heddwch> You can do let mut a = &mut b, though :p

< mbrubeck> There are similar things that are illegal though, like "let b = something(); let a = &mut b;"

< mbrubeck> (can't borrow a mutable reference to an immutable value)

< phoe_krk> :P

< phoe_krk> I see

< phoe_krk> This sounds fairly sane, too.

< phoe_krk> And very implementable.

< heddwch> Well, yea, it's implementable. The compiler is already implemented :p

< phoe_krk> Mutability, ownership and borrowing.

< phoe_krk> heddwch: i mean, in CL.

< phoe_krk> If it's good, then I'll copy it.

< heddwch> ah

< phoe_krk> (that's the way that programming languages have been going for the last 20 years in relation to Lisp, anyway~)

< phoe_krk> Anyway!

< phoe_krk> Just random thoughts that I'll be publishing on a blog of sorts.

< heddwch> I think you just did, with the blog being ##rust

< phoe_krk> heddwch: nope, it's not a blog

< phoe_krk> had a good deal of conversation around here while I was thinking aloud

< heddwch> ah

< phoe_krk> this might have not appeared in this form if I didn't post this here :P

So, with all due respect - thanks, ##rust!

(I have to find out how to properly insert codeblocks in Tumblr.)

[phoe-krk]

There is a big blog post I have made over there, about the current state of documentation in Common Lisp.

[phoe-krk]

Just a random tiny update to show you I ain’t dead. Just been a really tedious month or two.

Learning OO Common Lisp in meantime.

[phoe-krk]

Public key

Oh, just in case - here’s my PGP public key.

-----BEGIN PGP PUBLIC KEY BLOCK----- Version: GnuPG v2

mQENBFYrhSABCADYlzn5qT/TPl91k68fjOFJ54FR0H15JG5+KQCVm/dmCA794u/h 4rknj9nTp6JWy/ZJi/yEEQuNwoucpGYi31oBZBKINghPQlCEjgWlbgZKq8KxWQCS gl/eJPg/0/fc7T/pYiVM6xaFbavdLmzFp9VVo9f/KxPUq1gem/7AY2pFzcOuDuv7 JOp3cb6htzGpnxc5M5f/xyK8g+fXeEYjEUNypkptRkFZcxnNoPS95EpA9XOweGmc p8lXeWtWS8Gy+k5YKVnsxu7YPD2eXVRIzNZTDQogFPHwOBRgDsmfUeN+nE6YOtWT XMum/PeTt+UZPrXpGAgV7rq2H0gzXjJS1FWlABEBAAG0K01pY2hhxYIgSGVyZGEg KHBob2UpIDxwaG9lQG9wZW5tYWlsYm94Lm9yZz6JATkEEwEIACMFAlYrhSACGwMH CwkIBwMCAQYVCAIJCgsEFgIDAQIeAQIXgAAKCRAkY5zRTuj7NTCvCACGpgAokeRz ZZtnR86+lt3+zkC1SXtILl7GGnTwR2C13obG9Fk9vrydR1EGNWhRIePlF5oK/mei 1PEX/r7LksRk0QnhBWSAoW5GorYorDE172Aic3TTZWYuNfW/S9XoXSzPITlEpOaB nb4IoF6Pu7wMc3CgU30UgNAHvBjRqMAtzlZFw39yl5dn200lYnX1TvhfDGavgSRH +M1IvA4gvJl5vVidrJFO3JKWDJ/nnitCLKDLUM3ShqFnQd1nYtTGoosgKAMW/7oo +/8dRLTbaFJzWgnYnLQYuggHLEVeRXxM5ByEHhbFrXiHZ5Rtt6jCjD9h33tgs+P6 jjSqp4a7YdfDuQENBFYrhSABCACh8wEWdaDcEFxs3W7jRSY3u2mwLsK86HC3OJju 1oS3it9mzGwgFH0NP2Ss2MeuN67KfrFchsXQktabJJNMncXug9Ra2aMHFFjQxluh WIhqxoSGM5FW1lkkXqcyL1gVo+KRHgNi5Y6ed2RzLXDXktQPrfe6VvGLEdkZBTXG m2fhYmhH1UFAC40fvJVD3vq1hzEyyd3a7W+YYqMEs4kZygelZTlKARaAp5bvw6PC S5gdYcjmSHCFdYkIZjnfZoz+E71ZSZwMKLSgj0V5X5kkcsX2ulQSLwDEPyZX1MoQ 8dmOn/JFFB5eQtNKvxwgePkjYOpDgzv9uNnz6AfNIq+iyIDjABEBAAGJAR8EGAEI AAkFAlYrhSACGwwACgkQJGOc0U7o+zX3ZQgAxdUw+PMGlrNEVPMTQxH9IXcLNtL4 +LKaZ0nNBKedcEDbTtaERNOOzgm07bLX2YdleAGxqELUxYPbb1mtbM233Hx8w/wG XLOsHTMhm4y0hPSp/4Karxl+WS2CzijnWqn+MB7zV1I9A18h5PZqEwbrgQ0dU4L1 aezRCVY4owb5/DksuxSQhEFP0DBaaIbm5sQpP+ecfnmLjEO6AHhmswei2aeolRwS yL7DOMOB3xMzsPJRrAeDD2ckvIpJb8UFqtZB/izxh4FyHr6UKBlBmgKp0vdOFVBA As9n2IwRxtoCJ+hoTBf7o83Zl5NOaO13nkm//1qRB+tjzGfJTn/qyvc19A== =LCym -----END PGP PUBLIC KEY BLOCK-----

[phoe-krk]

That face when SBCL, no matter what, won’t give you the same ASCII string in its inferior-lisp and slime-repl.

That face when ECL, no matter what, won’t give you the same ASCII string in its inferior-lisp and slime-repl.

That face when CCL magically works.

o_o; delicate SBCL-to-CCL migration sound

[phoe-krk]

personal rant #0

Furcadia is slowly doing all the things to make me work on lispfurc more.

.ini login is slowly becoming deprecated in favor of character accounts. I’ll need to wireshark the new (account) style of logging in once the update is pushed out and make a lispfurc wrapper for logging a particular character name in with a particular description. Basically, your own database of characters, once the Furcadia\Furcadia Characters folder goes to hell.

FurEd is slowly becoming deprecated in favor of the web furre editor. I'll need to be able to hook it into lispfurc so an user can edit all they want and then send the new color code into lispfurc.

After I tweak the proxy around a little bit, the next thing I want to create is a persistence proxy. Something that acts as a microserver - basically keeps your character always connected to Furcadia's main server and you are able to transparently connect your main character in and out to the proxy with the official client, getting all the whispers your character gathered while staying in the semi-offline state. That would be fun for keeping characters online who need to stay online, like, for keeping dreams online. Implemented on some high-availability server to assure highest possible uptime, with some basic trust when it comes to handling login information, that would be a fun third-party addition to Furcadia, I hope.

Then, fix the mess that DragonSpeak is, implementing my own DS engine in lispfurc and fixing all the stuff I consider broken in DS in a way that is transparent to the clients, even the official one. It would greatly simplify the protocol when it comes to DS without removing any functionality present in it, for example, implementing a single way of moving furres around without walking animation and a single way -||- with walking animation, compared to the many DS lines that are currently sendable, each of which the client has to implement to be able to comprehend the changing dream state. n+1 ways of doing the same thing is n too many when it comes to the number of possible messages you get from the server and conserving bandwidth isn't a problem anymore; it's no longer 1998.

And, once I have that, I have most of the hard things for writing my own client done. The rest is just poetry.

[phoe-krk]

lispfurcproxy is multithreaded now.

let me fix just a few more code issues and I’ll make a git commit.

[phoe-krk]

LispFurcProxy in action.

Freshly finished. Still warm.

[phoe-krk]

Welcome to RPedia! Here to help answer questions and give information for roleplayers and writers...

RPedia: that’s one awesome resource for roleplayers that I simply want to have on my tumblr.

[phoe-krk]

Furcadia: not even once.

(I know these should be defvars and not defuns, don’t go screaming at me for that.~)