Well a blog will be fine if it is narrowly focused on technical issues, ideas, and concepts put in a positive way (emphasis on positive).

This post is very interesting I'd appreciate you elaborating on this a little more

Well of course I would never mention any direct information like my identity, the name of the company, or any particulars about the software, but I'm sure it will be inevitable that if somehow it just so happened a co-worker fell upon it, they would be able to put two and two together.

I would mainly be writing it to document the learning and development process in the software development world from ground zero. As clowntable said, I think it would be greatly beneficial for myself, let alone I would like to provide a glimpse into the world for others who are considering it.

We shall see.

Bitching about work on the internet is not the way to start your career. Anything that sounds remotely negative about work or co-workers shouldn't be on here. Especially if you're going to make a habit of writing about work.

I'd assume it just doesn't have the power to do ~2500 css transitions at once.

Try this one see if its any better on iPad if you wouldn't mind. More or less the same on desktop. http://jsfiddle.net/TVfE8/

Kind of confused as to why people assume this is what I would be doing. It is so far removed from the reason why I would want to write about my experience and what I would be writing about.

All of our code started with two of us who were both pretty experienced in software development in general and at least relatively experienced with Python.

The problems we hit aren't even so much because of bad code. Its not bad as far as projects go and its definitely tested more than the average project (although not as much as it could be).

The things that are painful are more structural to Python itself. Tracing through code is harder (With any good Java tool you're always one click away from a variables definition and declaration). Refactoring structural changes is harder (Java tools let you refactor a method signature quite simply or at least show you every instance of that method being called that is now broken). General refactoring like extracting variables/methods/classes, renaming variables, modifying an object hierarchy, etc. are all easier with existing Java tools. And so on.

In practice, I also find that Python leads to sloppier code in certain situations. If you actually have logic that really benefits from a complex object hierarchy I find its much harder to create and maintain that in Python than it is in Java. The flip side of that is that Java too often forces you into stupid Object verbosity when you don't need/want it - but most Java tools make that at most a minor annoyance.

Python is also a bit more fragile in certain ways. For example if you have a large long-lived code base touched by multiple people you generally end up with some sections that are rarely modified/executed/understood. If you don't have a test for that logic its easy to create a bug in that code (say with a simple variable typo) that doesn't get caught until a very inconvenient time.

Any specific parts?

This renders a bit slow on my 'Droid and it creates a strange layout. There are lines of dead pixels that create grid-lines across the image although the image, without the lines, looks fine.

Because being frustrated at work, particularly with a new career, is par for the course. Just pretend that you're sending it to every one of your bosses and coworkers before hitting post and you should be fine.

I like that tip, thanks, will definitely use that.

i don't see how any of these are structural to python itself; these are all features of the java ecosystem. i agree that these things are more mature in java land, but it has nothing to do with weaknesses in the python language or its implementation.

i agree that python, being more flexible, can be more prone to overly clever code. this is probably worse than the kinds of overly stupid code you tend to get from a more rigid language.

i'll spare everyone the "if you have a complex object hierarchy it's because you don't understand your domain well enough" derail but i agree that if you *do* need a complex inheritance tree then python's oo stuff is weak and capricious ("meh, i'll call the method from whichever parent i happen to find first").

this happens in all languages, as you know. i don't see how python is any better or worse, really.

there are a few problems that static typing can catch early, but ime these problems never arise when passing simple data structures around (where static types would keep you out of trouble) and only show up when passing complex data structures (which typically require deeper, business-logic-specific validation anyway).

I don't want to get into semantics and it seems like we agree on the main point.


Complex doesn't need to be that complex. I can think of at least half a dozen instances in our code base that has a 3 or 4 level inheritance hierarchy that makes a ton of sense.


Python has way more of these situations than Java. Wrong data types. Invalid variables. Mistyped variable names. Miscalled method signatures. And so on.

I accept the pepsi challenge!

I'd wager that, if the problem isn't too difficult to describe, I can come up with a better solution that uses no hierarchy, or perhaps 1 level.

Meh, I don't care enough to try to generalize our code and the examples. But if your contention is that any/all 3+ level object hierarchy can be better solved with no hierarchy or at best 1 level that seems pretty silly to me.

I don't think it's silly at all. It's just a preference for composition. Again, feel free to challenge with a counterexample, even if you want to invent one.

EDIT:

For example, see here: http://nathany.com/good/
Go doesn't even have inheritance, apparently, and that quote from Sandi Metz below it is from this book (which I recommend, btw): http://www.amazon.com/Practical-Obje...1708512&sr=1-1

I don't. Seems like an argument thats not worth winning. Cool though.

I suspect there are a lot of times in C++ and Java where you *need* a complex object hierarchy in order to accomplish the kinds of things where a Python developer would use other tools.

Leaving aside the implicit debate over which language design is superior, you shouldn't fight the language you're using.

Oh please, I haven't found a language yet that I couldn't write COBOL with.

@Neil, i actually dont think that's true. the typical replacement is a design using delegation and composition, both of which are well supported by java.

to me, first class functions is the most salient missing feature from java, but even those can be faked using anonymous classes and interfaces -- it's just a lot more verbose. in any case i think the class hierarchy debate is a mostly orthogonal issue.

What's your criteria for better ?

Because it is basically one of the few things that would be problematic? Why would you be reluctant to do a blog with your stated goals? If you wanton devote the time to it why wouldn't you do it?

more cohesion, looser coupling, easier to change, simpler, easier to remember (less cognitive load)... those would be the big high level things. if you meant to suggest a philosophical "well who's to say what's better? it's all subjective anyway...." then we'll have to agree to disagree, or in my case, agree to violently disagree

This is sort of why I don't want to get into an actual example or debate on this question. "Easier to change", "Simpler", "Easier to remember" are all super subjective things - especially in the context of a toy example. And generally people are going to feel that the things they are most familiar with are "Easier to change", "Simpler", "easier to remember" than the alternatives.

That was just a high level answer to the question. My original point was that with an actual example I would be able to convince you easily with a refactor. If I couldn't convince you, then I lose the pepsi challenge. Of course, it's possible I think it's clearly better and you disagree, but I was betting that wouldn't happen.

Yeah, I understood that. But I'm not going to put up our actual code here, and coming up with a generic example that is simple to explain/work with but maintains all of the real world complexities that make inheritance useful is too much work.

I'm actually not a huge inheritance nut. Composition/Delegation is certainly preferable in many places. But I also don't think its that rare to have a domain where something fits into a nice object hierarchy and inheritance/polymorphism works really well, and so on.

And when you get right down to it I actually don't think its that important to the original point. I could probably replace "complex object hierarchy" with "complex problem domain" and the point is still valid that its easier to model/work with/refactor in Java than it is in Python regardless of how you actually implement the functionality.