Adobe Destroys Software Industry

Adobe logo

Adobe is proving out the monthly payment business model for high end computer software. I hate it.

For many people, it’s probably not a bad deal. The monthly fee for Photoshop seems a pittance compared to the much larger price the behemoth once charged for the software. It’s particularly powerful for those who might not need to use PS every month.

But I hate paying monthly for software. I understand why companies love the recurring revenue. It’s smart business for them. But I do everything I can to not pay monthly for software. I prefer to pay once and then for major upgrades. Sometimes, I skip a version, which makes the initial investment in the software pay off even better. With monthly pay
Adobe changed that, and it’s working for them, and we’re all screwed.

Today Adobe reported its first quarter earnings for 2016, yet again revealing “record” quarterly revenue. This time the company raked in revenues of $1.38 billion and $0.66 earnings per share (non-GAAP). Adobe has set a revenue record for the past three quarters.

Even with all the internet gnashing of teeth over it, everyone still ponies up who needs the software. It’s industry standard in so many places. You can’t avoid it.

With a huge company like Adobe proving the concept out, others will follow suit. The business model works. Why wouldn’t others do the same?

I can only hope they don’t move to this monthly standard for Lightroom next. It’s the last hold-out of the one-time-only pay model. Yes, you can pay for it monthly in a package deal with Photoshop, as I recall, but the standalone model is still an option.

You can use alternatives like Acorn (for the Mac) or GIMP (if you’re REALLY not into spending money, or just adore Linux), but the world has standardized on too many Adobe products. There’s no going away from them, and now their monthly pay model is going to be normalized and standardized.

We’re screwed.

For the record, I’m using Acorn, Clip Studio Paint, and Lightroom for most all of my photographic and graphic needs. They’re all paid for.

Once.

Apple Computers are Cheap

Apple iMac box

My first computer was a Commodore 64. I used it for 12 years. (OK, it was the family computer, purchased around Christmas of 1983, I believe. After a few years, I was the only one using it. I used it up until 1994 for all my school work, amongst other things.)

Then I bought a series of Windows machines. Every two years or so, I’d spend another $1500 -$2000 on computer, usually from Gateway (and then Gateway 2K).

In 2004, I switch to Mac and bought a Power Mac. In 2010, I picked up an iMac. In 2016 now, I bought a new iMac with a Retina Display.

Everyone’s first reaction is, "Whoa, that must have cost a bundle."

No, actually, it’s cheaper than those Windows computers ever were. These Macs have lasted, on average, two to three times as long as the PCs, for just slightly more than what I was buying a PC at. And this 2010 Mac is still a viable machine, and will be handed down so it can continue to be used far into the future.

Zynga: Good Riddance to Bad Rubbish

Zynga is floundering, and I’m here to jump prematurely on its grave a little…

Zynga logo

A year and a half ago, I appeared on a morning show on CNBC to talk about a comic book auction. While I was in the green room, a segment was airing that talked about Zynga and its rising fortunes. 1

I fumed a bit, because I knew that the person reporting this had to be tech illiterate to not see how bad an investment Zynga was. How Zynga relied on games it copycatted, if not outright stole. How it survived only because it preyed on weak game players and those who are stupid enough to spend money on disposable digital assets.

In a follow-up email with the producers of my segment, I mentioned that if they even needed someone to appear to talk about how ludicrous Zynga is, let me know and I’d be happy to come on.

I said it half jokingly, because I knew nothing would come of it. I have no status in the tech or financial world. I’m just a computer programmer who followed Apple too closely, right? Why would they put me on air? At least with the comics, they can credit me to “ComicBookResources.com“.

It took a little longer than expected, but the Fall of Zynga is well underway. Besides losing its CEO again (and paying the new one close to $2 million), it’s astounding losses have mounted to a billion dollars. The inertia of its early successes carried it this far, but it’s not going to last much longer.

Schadenfreude.

  1. The segment likely also featured King of Candy Crush fame. My opinion is much the same. Zynga is just more evil about it.

I’m on the Elixir Fountain Podcast!

Elixir Drop records a podcast with Elixir Fountain

Recorded on Wednesday, today sees the release of my conversation with the ever-amiable Johnny Winn on the topic of Elixir. And Phoenix. And Perl. And Ruby. I may have even mentioned Haskell at some point in there. We cover a lot of stuff. (And then we talked comics, naturally.)

It was only afterwards that I realized I’m a complete blabbermouth and didn’t go too deep on any one topic and likely will need to explain myself at length on a couple of things after the fact.

In other words: More blogging material! =)

But if you have any questions, leave a comment or send me a tweet, and I might just make a post here out of it. Thanks!

The Joy of C

I don’t like C. I know why it’s good and why it’s important to know. I took the class in college. I’m just saying it’s not fun.

my college copy of The Joy of C

Here’s my college C textbook. Note the sad face in the middle. And I think that’s the word “skipping” scrawled in the appropriate place in Sharpie.

Like anyone new to programming at that level, pointers drove me nuts for a semester. I get them now, but I also haven’t had to use a pointer to a pointer since college. This makes me happy.

Core Elixir: List Module Misc.

Core Elixir looks into the List module and finds Erlang wrappers, test-driven development, and the joy of tuples.

We’ll be dipping a toe into the List module waters today…1

Elixir Drop dips his toe into the water

In researching modules and functions for Core Elixir, I often come across dead ends. These are the functions that don’t go very deep and that aren’t very interesting for a Core Elixir article.

The #1 cause of this is Erlang functions that are called directly by Elixir just to switch the parameters around so the list or collection comes first. Thanks, Pipeline Operator.

For example:

List.duplicate/2 takes a list and a non negative integer that describes how many times the caller wants to repeat that list. So, to steal the example straight out of the documentation:


iex> List.duplicate([1,2], 2)
[[1,2], [1,2]]

You know how that works? List.duplicate(list, multiplier) calls Erlang’s :lists.duplicate(multiplier, list).

For Core Elixir purposes, that’s a dead end.

That seems simple, but Elixir goes one step simpler:

List.flatten/1 directly calls :lists.flatten/1. It doesn’t even need to swap the order of the parameters around, since there’s only one.

But, wait, you say, there’s another version of List.flatten that has an arity of 2! The second parameter is a value that gets slapped on at the end of the newly flattened list! Does that extra parameter make any difference?

No. List.flatten(list, tail) calls :lists.flatten(list, tail).

The list still comes first. Erlang is inconsistent compared to Elixir in this way.

Purely Functional Looks Test Driven

I like this bit of code, to define List.last, the biggest tongue twister in Elixir’s code base:


  def last([]),    do: nil
  def last([h]),   do: h
  def last([_|t]), do: last(t)

It feels like the way you’d write something when you’re test driving it, doesn’t it? Let’s work through it:

Make it work for the simplest possible case — an empty list. In that case, there’s no making heads or tails of it (ha!), so you return a nil.

OK, so what happens when there’s only one item in the list? The answer isn’t nil anymore. You need to write that case next. The single value is the head AND the last item in the list.

And when you have two or more items? You look for the last value in the list by going through the whole list until you get to the end, recursively. Keep stripping off the head from the list and look for the last of the rest.

As a bonus, the second case now makes more sense. Why is the single value the last value? Because if you started with two or more values, this is the base case. A list with one value would effectively be the most tail item in the list. Pretty nifty.

It’s logic like that that makes me like functional programming. It just feels smart, somehow.

Of Tuples and Keyfinds

List.keyfind/3 strikes me as funny, mostly because it isn’t what I thought it was at first. And then I felt stupid for missing it. Let me assume for the moment that we’re all being honest with ourselves and that all of our minds blank at something ridiculously basic every once in a while. Thanks.

`List.keyfind/3′ calls on the similarly named :lists.keyfind/3, like so:


  def keyfind(list, key, position, default \\ nil) do
    :lists.keyfind(key, position + 1, list) || default
  end

The function takes a list of tuples ( [a: 1, b: 2, c: 3] ), a value that it’s looking for, and which position in each tuple it’s looking for that value.

Here’s the trick to remember: A tuple can have not just two values, but also more or less than 2 values. A tuple is just an ordered list of things. Curly braces surround the list, and the values inside are separated by commas.

Valid tuples:
* {1}
* {1,2}
* {1,2,3}
* {1,2,3,4}

Et cetera. Well, you probably want to use a map after that, instead, but it’s your program. Do what you want.

When you have a two element tuple, it’s not a key and a value. It’s just two values.

I had forgotten that in a list with keywords, the curly braces can be dropped.


iex> t1 = [a: 1, b: 2]
[a: 1, b: 2]

iex> List.first(t1)
{:a, 1}

See? That’s a list with two tuples. Each is kinda sorta key and value, but not really. It’s position 0 and position 1 in a two element tuple. [a: 1, b: 2] is the same thing as [{:a, 1}, {:b, 1}]. It just looks a lot cleaner, so long as you remember that little trick. I’m a little out of practice using it, I guess.

In List.keyfind, the position parameter refers to which value you’re looking at in each tuple, the zeroth or the first, in these cases. For what I think of as the key, I’d always use 0. For what is traditionally the value, it’s a 1.

If I wanted to make a ridiculous pull request to the Elixir core language, I’d offer up positions of :key and :value that are equal to 0 and 1 in two element tuples. (Pro tip: Don’t do it. It’s a silly idea.)

Finally, the last parameter sent to List.keyfind is the default value to return if nothing is found. “Nil” is the default default.

There’s one other gotcha to point out here in this code. Erlang likes to be a 1-based language, while Elixir likes the 0-based values. List.keyfind calls :lists.keyfind, moving the list to the front and adding 1 to the position value to make up for that off-by-one position.

You may all quibble amongst yourself over whether everything should start with 0 or 1. I’ll be over here indenting my code with the tab key just to annoy you.

I’m just kidding. I would never do that. I program in a non fixed width font, so indentations never looks right no matter which keys I use.

Sorry, I’m kidding again. I don’t use a non fixed width font. That’s madness! But this switch to a Dvorak keyboards means d;jdsfo dsmowm ojf of s;ljfy. !

(17)

  1. This might just be the best Elixir Drop drawing I’ve done yet. Just sayin’