Traffic, Technology, and Treasure

These are my lean startup experiences for October. It's a concrete example of how I've applied the “build-measure-learn” approach to Blender Addons during the past month.

Growth by Weekly Release

The big experiment was seeing whether or not I could raise traffic 35% in a month by doing weekly add-on releases for Blender. Results exceeded expectations with a growth of 56% for October. However, traffic by itself is just a vanity metric.

The details in the traffic data said a lot about what users want. A script called “Curve Mangler” released early on in the month gave traffic an early bump because visitors like curve add-ons. On the other hand, the “Orphan Cleanup” data utility add-on didn't excite people as much. 

The clues are in Google Analytics. Digging deep uncovers an interesting form of indirect communication. Users often will express their desires by way of their behavior at the site. It's a great way to help set priorities in a way that helps to reach goals.

Direct communication also plays a big part. My tools in this regard are forum boards and social networks. It's great for morale because it makes me feel part of a community. I learn a lot from them. Their feedback and encouragement helps me make my add-ons better. It also helps drive traffic to my site.

Testing Technical Assumptions

It is okay to do a technical experiment just to satisfy curiosity so long as you have a set definition of success or failure within a reasonable amount of time. For example, I wanted to see if I could easily control particle fountains with an armature. The experiment failed. I'm okay with that.

Failure is sometimes the womb through which better ideas are born. In this particular case, I found a way to use generated curves to provide new ways to visualize and test out armatures. This means a new add-on project to kick off November with.

Money Pressure vs. Money Goals

A startup needs to turn a profit at some point. My approach was to put that issue on the back burner. It made more sense to focus on building up a decent reputation as an open source developer while also securing a day job. That much has been done.

Here's another reason it was right to wait til now.  I believe money pressure for a startup is a bad thing because it's distracting. Money goals, on the other hand, are generally good. The key thing is to be in the position to start off with a modest goal. It makes no sense to try making 2000 dollars in a month when I haven't even proved I could pull in 20. A modest financial metric can be handled just like any other piece of data. Less pressure allows for clearer thinking and, in turn, smarter pivots.

Closing Thoughts

October was a great month and I am excited about what November might bring. New add-on projects, a new day job, and other things in the work ensure there's never a dull moment. I look forward to reporting new progress soon.

When It Feels Like a Video Game

Wow!  This was a wild week.  Someone in the Blender project gave me commit rights to one of their repositories.  Huge honor!  On top of that, the Mohegan Sun Casino hired me as a Java programmer.  Big relief!  Despite all the excitement, a lot still happened with Blender Addons. 

Here's what's happening there.

1.  Step Pyramid appears to going into the next official Blender release.
2.  Particle Tracer is in consideration for a later release.
3.  "Particle Man", "Orphan Slayer", and "Mangler Suite" are addons in development for October.
4.  Disappointing September traffic lead to new site design tweaks for Blender Addons.

Lean startup principles helped me get all this in motion.  Time with users and studying the results of my past work helped inform my next move.  Even the failures, unpleasant as they were, gave me a sweet data set to work off of. 

Of course, the most fascinating thing about this whole learn-and-build process is it feels like a video game.  There's something about it that reminds me of the hours of Civilization and Caesar that I used to put in.  I can't put it into words why that is but I'm sure not complaining.  It's intense but it's also a heck of a lot of fun.

Old Tutorials and New Utilities

My first week using of using a lean startup style to Blender Addons has been interesting. The lean approach is already turning out to be an excellent learning tool. Here are the results so far on what I've learned and done.

Khan Academy and 3D Math

Khan Academy does a good job at teaching the basics of linear algebra. The topic of matrices is very well done. Manipulating these structures is key to understanding how moving, rotating, and scaling 3D scene objects work.

For math specific to curves, trigonometry and quaternions look like concepts worth looking into. Trig math shows up all over the place with curves.  Quaternions seem to appear in a lot of round shapes. This should open up some interesting possibilities.

PHP Reduction

Blender Addons could get by fine with less PHP. Templates can probably be done with JQuery. Code coloring can be done with a JQuery plugin. Dialing back PHP will open up more web hosting options. Hopefully, those options will include one with Django support.

Retirement of the 2.49 Tutorials

The Blender 2.49 tutorials become less relevant as time goes on. This justified a new “retired” section for those tutorials. It makes more sense to deprecate them rather than remove them outright. They still serves a purpose for people who want to port over scripts to the new API or for people who haven't moved to 2.5 for whatever reason.

New Utility Script for Developers

Every decent developer will find themselves, at one time or another, making tools to automate certain tasks. My own collection of tools were added to the site today. They include module searching lambdas along with functions for handling materials and deleting data. They've been very handy for me and, hopefully, will be likewise for other coders.

Conclusions

So that's all there is for now. It's back to work now to see what can be made of this coming week. Cheers.

Lean Startup Ideas For Blender Addons

Blender Addons has been a fun hobby and a great excuse to play with technology. With some guidance from “The Lean Startup” by Eric Ries, it could become a profitable business too. Here are some ideas that might help towards that goal.

Build, Measure, Learn

My most successful add-ons are related to curves. I learned this by messing with the layout, making predictions, and scrutinizing the following week's traffic data. Experiments like this help clue me in on what kind of script to do next.

Waste Elimination

The Game PD project saved me money on games and helped sharpen my tech skills. Alas, by lean startup principles, it is technically waste work. It doesn't serve my users and it adds zero value to the business. This isn't to say learning tech skills on a just-for-fun project is a bad thing. What it means is that work that directly serves the user deserves higher priority.

User Community

It pays to spend time getting to know users better. In the case of Blender Addons, forum participation is one good way to get to know the kinds of things they think about. For example, linear algebra is one thing that matters a lot to my fellow developers. From that, I was able to make Khan Academy time on the topic a priority for the coming week.

Weekly Batch

Releasing project features in small batches may have some advantages. It's likely more satisfying to release a few things at once rather than put out each thing as it's finished. Furthermore, batches released at the start of the week make it easy to measure traffic for that week.

Growth and Pivots

Site traffic has been flat for the past 3 weeks because it's been that long since the last update. This is bad. To remedy this, I set a specific web traffic goal and deadline to shoot for. I also established projects and strategies for getting my numbers up. If it fails, the data I collect should help me decide my next move. This direction change would be my “pivot”.

Final Thoughts

Like all good intentions, I fully expect life to get in the way. Everybody, including startup founders, deals with that. However, if things go even half as well as I hope, this could be a major turning point for my site. It should make for some interesting future blog entries.

Colors, Web Apps, and Google

I haven't talked projects in awhile and I'm due to get back on that track. So let's get started.

Random Face Color Addon

I wrote a Blender add-on that randomly colors all the faces on a mesh. This was a special project thanks to Blender Artists forum involvement. Someone suggested features the original version didn't have. That lead to new monochrome and animation features. It was a great learning experience and the script got a thumbs up. It felt good to be told I did a good job.

Web Applications for Blender

I revisited the idea of loading Blender data into PHP. This time, I listed the names of every object in a project separated by data category. Materials, meshes, and everything else got their own section. The bad news was I couldn't run Blender on my web host which meant no production deployment.  Back to the drawing board.

I looked to Github for inspiration. Getting the most out of that site means having Git installed on your computer. It's a setup that works really well and opens up an interesting question. Can Blender have a relationship with a web application similar to the one between Git and Github? It's an interesting idea.

Exploring App Engine

Exploring technology is key to executing ideas and I decided now was the time to look into Google AppEngine as a potential platform. The learning curve thus far is about as good as that of Django.

Of course, the recent pricing drama makes App Engine look like a risk that I might not be able to afford. However, I'm willing to give it the benefit of a doubt. It'll be awhile before I deploy anything which should give Google time to sort these issues out. Also, Google has made mistakes before with Buzz and Wave and managed to correct course. I'm hopeful that this will be just another trip in Google's history of awkward stumbles.

Ending Thoughts

There are other things I've played with that I didn't bring up because it would make this entry too long. So rather than going into things like Backbone.js and Python package hierarchies, I think I'll just end it here. May your coming week be fun. Will talk again soon.

Do Programming Language Skills Exist?

I don't have Python skills. It's true I have programming experience where I've heavily used Python for the past couple of years.  Still, I have a hard time seeing Python as a skill. In fact, I have a hard time believing any of my programming language skills are real.

Making the Case

Programming skills may exist may exist but programming language skills do not.   Let's consider the differences.

Skills	Not Skills
Object-oriented Functional Imperative	Java Haskell Python

Let's pick on Java.  Java is a tool, not a skill. Real skills are working with concepts like inheritance, compile time type checking, branching, looping and more. None of these concepts are unique to any one language. Understanding that makes picking up new programming languages a breeze.

Does knowledge of standard libraries on a language platform count? Not really. It means you're good at learning libraries. It says nothing about your programming skills. You could spend years working with different Javascript libraries without understanding what a closure is for example.

Don't Limit Yourself

The idea of a language as a skill limits you as a developer.  For one, it limits your thinking to the features your language supports.  Even worse, it puts too much faith in what that your language can do. Stop doing that. Start putting more faith in what YOU can do as a programmer beyond the language. You'll be a better developer for it.

Script Tweaks and the Return of Falling Blocks

Last week was awesome. Lots of cool stuff got done with web apps, Blender development, and a touch of Java. Let's get right to it, shall we?

Game PD: JSON and Updating the Updater

A couple of unused columns got dropped out of Game PD's database. This required a little bit of SQL and a couple of small changes to the updater script. Brand new decorators now do some argument checking against data class methods. It was great. Decorators are a fun Python feature to revisit. There's a handy tutorial that helped me relearn the weird bits.  This exercise also turns out to be a nice way to practice writing secure code.

On the web app side of things, Game PD's front end completed the switch from a table to div layout. The data feed stopped passing PHP arrays and started passing in JSON data. This will send the old game table template into retirement. Furthermore, it mostly dialed back PHP's role to that of a data provider. The layout still needs work but it's nothing that can't be resolved with some CSS tweaks.

Blender Addons: Ani-Mangler and Materials

Ani-mangler got a small update. It now offers a convenient way to name shape keys as they're made. You now can generate shape keys auto-named “subtle” for small deformations or “violent” if you decide to really crank the settings on it.

In other Blender news, API options for messing with materials caught my attention. The devs made it easy to climb the learning curve but I'm not ready to put out anything yet.  Hopefully, there will be more on that next week.

Java: Falling Blocks Comes to Github

Falling Blocks is a Tetris clone I wrote some years ago as support material for a professor's game programming class. It was the third of three games that showed how easy it can be to develop games in Java. Aside from sound issues, it still runs pretty well. It's now available to you via my Github account. It's a proud part of my history and I hope you like it.

Conclusions

It was a busy and productive week but there is still much to do on all fronts. As always, I'll keep you readers posted on new developments.

Everything But The Blender

Weeks that include interviews mean less work on projects. This was especially true last week where the interview was with a New York City startup. Just the same, there are a few interesting things worth talking about.

Apache Configuration

For the longest time, Blender Addons and Game PD shared a common folder which made version control difficult. Now, both projects have their own folders. Setup meant making separate sites-available files and writing a BASH script to automate Apache reloads.  Once done, switching between web site projects became a simple one-line command.

Python Is Awesome

I like doing small experiments in Python enough to write up quick scripts here and there for fun. One project used operating system utilities to examine different aspects of my /etc/ directory. Another project on the topic of continuations taught me a functional programming trick for passing in what courses of action the target function should take next. Give “python continuations” a Google search. You'll be glad you did.

Learning continuations got me thinking about the relationship between programming languages and paradigms. With Java, I felt pushed to think in object-oriented terms. Haskell is a functional programming language and, as such, pushes that style of development.

Python never made me feel pressured to adopt one style over another. I learned its style of classes and inheritance when I was ready for it and picked up functional programming tricks when I decided it was time for that. To pull that off while keeping the language simple is impressive.

PHP with Cookies, Sessions, and JSON

I finished a session and cookie manager that I did for myself as a challenge and came away from it pretty satisfied. This project mattered because sessions were the only major web programming area from my JSP days that I didn't have a handle on in PHP. It was a big win. There is still a lot to be learned though.

Take JSON for example.  I just finished off some work on a project where I was feeding JSON data from the server to client-side Javascript. Parsing it via JQuery was a little weird at first but, overall, it wasn't a difficult learning curve. Compared to XML parsing, JSON is easy.

In Conclusion 

After all is said and done, only Blender scripting fell to the wayside. That's something I hope to remedy during the coming week.  I look forward to talking about that and more in the near future. 

Div Tags, Nodes, and Gentrification

Accomplishments are light compared to the week prior to this last one. Most weeks would in comparison. Job hunting distractions hit hard which meant fielding phone calls, writing emails, and doing research for interviews. The trade-off is it helps get me employed but takes away from project time. So here's what's happening.

Game PD – Div Research

The Game PD project's reliance on html tables for layout is embarrassing. To work towards fixing that problem, I experimented with organizing image files using css and div tags. It's a different way to manage things but I can see the degree of flexibility gained from doing it this way. The next step is to fix the tags in Game PD itself.

JMonkey – Node Experiement

This past week's JMonkey topic was the node system. JMonkey nodes are a little like css/div layout in that they help organize visual entities presented to the user. For my experiment, I took liberties with an existing tutorial on the topic. I gained experience in node set up, rotation, and scaling using the api. Aside from a snag with property settings, it went pretty well.

Blender Addons – Gentrification

A visit to New York City lead to research on gentrification, a topic that matters to Blender Addons. Gentrification refers to affluent people moving to poor neighborhoods and improving them. This causes the underclass to either adjust or move out because it becomes more expensive to live there. Some of the underclasses most affected are poor minorities and artists. This likely includes many 3D artists as well.  So gentrification serves as yet one more reminder that my audience is one of modest means.

This matters because I view Blender Addons as a business and the first rule of any business is to make a profit.  That means that the choice of target audience has consequences that cannot be ignored. I'll think this over carefully before making any decisions.

Conclusions

That's all for now. Aside from interviews, there's plenty of interesting work yet to be done. I'll keep you posted when I have new things to share. Cheers.

Blender Ops, MVC, and More Monkeys

I got a lot done last week. I'll do my best to keep this blog entry short. Let's get to the week in review.

Blender Addons - Blender Operators and CMS

String It got a point upgrade. It now has hook support so that the objects that the generated curve runs through actually attach to the objects themselves. Also, demo videos for this and my other scripts got posted to Youtube this past week. As an extra challenge, I wrote an operator that syncs rotation of multiple selected objects. This last script gave me good practice on modal ops but it probably won't make it to the site.

As Blender Addons grows, a cms system becomes more appealing. This and my web hosts support for it justified a local Joomla installation. However, it'll be awhile before a CMS switchover actually happens. Design issues need to be addressed first and it's not a trivial task. In the long run, it'll be worth it because the tools for managing and organizing content are pretty useful.

Game PD – MVC and the Javascript Bug Hunt

After spending time reviewing advanced PHP concepts, it became apparent that MVC style code layout could be done easily in Game PD. In Java web applications, it's pretty obvious what belongs in a data class, a controller servlet, and a JSP page. However, with the right amount of discipline and a few well placed require statements, you can have the same benefit in a PHP project too. This project now has the advantage of MVC style organization with none of the XML hassle.

A Javascript bug in the project taught me an important lesson about functional programming. Page navigation died when page reloads happened. The root cause turned out to be a function being accidentally passed to another function rather than it's result. It was a good debugging challenge and it served as a cautionary lesson about the kinds of traps you can fall into with this style of programming if you aren't careful.

JMonkey – The Red Ball

My latest baby step back into Java was a JMonkey project where I rewrote some code to turn a blue cube into a red sphere. What struck me as interesting was it felt like familiar territory already covered in tutorials I did on Python development for Blender. It was pretty easy stuff so I have to give credit where it's due. JMonkey, so far, is pretty friendly to newcomers.

In Summing Up

So between Blender Addons, Game PD, and JMonkey, my development endeavors have effectively evolved into a 3 projects. A lot got done and there's a lot more coming down the pipe. My backlog, as it stands, has 8 serious items to tackle and it's time to get to it. I look forward to sharing more next week.

A Cookie, A Monkey, And A Linked List

Blender Addons has a ways to prove itself. Five add-ons is a good start but there's still much to do. Here's what's been happening.

Particle Tracer

Particle Tracer is an add-on I wrote that uses particle locations to create curves. The order and/or chaos in the end result reflects the intention or degree of skill the user has when configuring a particle system. It's a good script for creating simple curves that look like flailing noodles or something fancier if that's what's desired.

JMonkey Investigation

JMonkey is a compromise. When I code unpaid and open source, it's computer graphics and Python and PHP are the right fit for what I do.  However, I'm also looking for paid work.  When tech recruiters say they want Java and .NET, they mean it.  The idea of accepting programmers from other languages doesn't fly. Since JMonkey is both Java-based and generally known and respected in the open source graphics community, I went with it.

My first impression is it's good. You can get a Netbeans based environment with all the libraries you need to start. The “Hello World” it gives you for a default project comes with a 3D cube you can interact with. Judging by the demo videos, it has a lot of good capabilities. There might be future projects in this.

Linked List Challenge

A famous interview question asks “How would you write a function to iterate backwards through a singly linked list in C?”. Most interviewees from entry-level to kernel hackers get it wrong and get eliminated for it. I wonder if they should.

The first thing I take issue with is the candidate is asked to do it in C. Most people's programming background is pretty high-level which would make C seem pretty intimidating.  Candidates should be focused on the problem without being distracted by the syntax of the language and C often makes that task needlessly more difficult.  Candidates should be allowed to use either pseudo-code or their comfort language to tackle these sorts of questions.

I wrote a Python function to solve the problem in 10 minutes which brings up the second issue I have with it. It's easy to solve the problem if you can think recursively. Recursive thinking comes easy if you do a lot of functional programming.  I use that kind of thinking frequently in the Python and Javascript code I write.  

However, I suspect most good enterprise and business developers manage just fine without functional or recursive thinking in their daily work.  It doesn't apply in every situation.  Most of the time, it doesn't even apply in the context of the job the candidate is interviewing for.

Cookie Setting in Uncle Squirrely

I decided I wanted Uncle Squirrely to remember what game ordering and platform they were last on when they left the app and came back later. It was a good excuse to get into cookies.

I had the cookie setting happen on the server side. I let a JQuery plugin handle the job of reading cookies and turning the data into a GET request. This meant the server-side didn't have to worry about how the data was coming in. It was a pretty simple yet interesting experiment overall.

And That's It

Another satisfying week done. I'm looking forward to the next one and you'll hear from me again soon. Cheers to all.

Junior/Mid-Level and Independent

The other day, a guy called to talk about a PHP developer position for an e-commerce site in Washington state. Washington is friendly territory for Amazon affiliates which makes it very appealing just on account of my own web sites. Having a solid background in PHP with no financial incentives certainly doesn't hurt as credibility goes. The qualifications matched beautifully. With a list made up of PHP, Javascript, CSS, SQL, and HTML, it would be difficult to be a more perfect match to my own skill set.

The only warning sign was getting an email before the official phone screen that the position required 5 years of PHP experience. Now experience is a funny duck. Any developer whose history is even remotely interesting will not spend 5 years working with one core language for all projects. My own experience was a delicious sandwich of server and client side technologies for all kinds of projects. Since PHP was what I started and ended with, you could call that language the bread I guess.

Here is something I find interesting. Back in college, a 3D site called I.L.B. Productions was my first personal web project which I did in PHP.  Fast forward to present day and you have Uncle Squirrely and Blender Python Tutorials which were my other two. Very little money was made on any of these projects but much fun was had. However, when it came down to the REAL phone screen, the woman I spoke with was not impressed enough with this or any of my non-PHP work to give me much consideration for the job. Experience with large scale e-commerce projects was a biggie and they wanted someone senior level for it.

Now there is a general rule that "senior developer" and "5+ years experience" of paid experience go hand-in-hand. My caliber is absolutely junior to mid so being judged as under-qualified for a "senior" role is fair. Part of the issue was because it was largely expected to be remote work and the client likes their junior and mid-level people to be physically there. So while relocation at this point in the job search is absolutely back on the table, senior is senior and there is no getting around that.

The "senior" vs. "junior" problem is interesting as job hunting goes. Dice.com searches show Connecticut has 26 senior developer job openings for every 1 junior position. The root cause of this situation is subject for debate. Still, this makes a layoff in the 2 to 5 year experience zone look like absolute death to such developers.

These are the challenges I face in the search for paid work. It's neither good nor bad but it is reality. So why on Earth do I still bang out code and throw that stuff out on the Internet if the odds are against me? Well, it's just plain fun. As for the job search itself, I like to quote Han Solo in Empire Strikes Back when he says...

"Never tell me the odds."

Add-On Development and the New Mission

Non-Blender Project Updates

The past week has been interesting as projects went. I tackled some older web technologies in the form of a regular expressions project and some Apache configuration research focused around CGI. These are pretty old technologies but still very much worth knowing about.

More On String It

The bigger deal of the past week was completing a new version of “String It” and putting it up on my site. String It has an actual user interface as well as support for two spline types now. I posted about it on the Blender Artists forums and the response has been pretty positive.

More About the Change in the Mission

I've said before that Python app scripting tutorials don't work as a business model. There are some things that can work though. Developing and selling add-ons for 3D tools can work. Writing open source software can also work. If both of these business models can succeed, then combining the approaches to base a business on open source 3D add-ons might work too.

This is why the official mission of the site will be making open source add-ons for Blender. “Blender Python Tutorials” will be renamed to “Blender Addons” to reflect this new focus. The tutorials will stay for the time being because they do add value to the site. Those that come for the tutorials will find the add-ons with full source code provide useful examples to learn from. Those who don't care about programming will also benefit from those same scripts. It's a win for everybody.

The Coming Week

The coming week will focus on two tracks. On the web track, there is obviously some site work to be done. On the add-on track, there are some small improvements on String It planned. The API support for particle scripting also looks pretty promising and worth experimenting with at least. It should be interesting to see how it all works out.

Curves, Regular Expressions, and Blender Data Pages

This was a pretty busy week that saw a lot of victories and interesting developments on small projects and experiments. Here are some of the highlights of what happened.

String It

Last week saw the release of String It. String It is a Blender add on that generates curves that run through the center of selected objects. Right now, it just supports bezier curves though future revisions could support other spline types. Also, it might one day include support for automated hook modifiers to bound the the objects to the curves that run through them.

Regular Expressions Challenge

Repetitive work involving removal of Amazon anchor tags inspired a scripting project to automate those kinds of tasks. A practice challenge with regular expressions on an old copy of one of my PHP files was called for. The project ran into some problems. For example, what does one do if there are two sets of anchor tags on the same line being evaluated? An oversimplified expression might match both sets along with any text between them. It's interesting enough to merit further investigation.

Blender Data Pages

One of last week's projects confirmed that it is possible to have a server script invoke Blender in a way that lets the script print blend data on a web page. The project only required a PHP page, a blend file, and a few lines of Python. While it was easy to do, security concerns prevent me from making a full project for production. Still, the idea of something called "Blender Data Pages" does have a nice ring to it.

Generator for Uncle Squirrely

Usage of the any() function in Uncle Squirrely's database update script made the code cleaner. However, that meant evaluations on whether or not a game belongs in the database had to go into lists. Since every evaluation in the list has to be evaluated, that caused an efficiency hit. Sacrificing performance for code aesthetics was not a good trade off.

Lazy evaluation courtesy a generator function is the best of both worlds. Basically, all I needed to do was put all my evaluations in it's own function. If you put yield statements between evaluations, what you get is a function that can be iterated on the same as you would with a range function. It was easy to learn, easy to implement, and lead to lazy code that looked great. All projects should be that easy.

Other Little Things

In the near future, Blender PythonTutorials will be an add-on focused site. Moving the add-on scripts link to the top is one step toward that goal.

Last, but not least, I have a special lambda utility I like using for searching module properties.  The problem is I found myself rewriting it everytime I needed it. Finally getting around to putting it in my PYTHON_PATH reduced that typing to an short import statement. It also made the utility available both in and out of Blender related Python projects. It should have been done sooner.

As you can see, it was a pretty busy week. I learned a lot, put good stuff out there for users, and got inspired to explore other ideas. These are the things that make software development the worthwhile endeavor that it is.

The Teacher is a Maker Now

The week's theme was on setbacks and moving forward in spite of them. Let's review what happened.

Broken Microphone

My microphone no longer records intelligible audio.  This killed the voice part of recording for the GUI and Panel Basics video tutorial.  Lack of money for new equipment forced a change of strategy.  Annotations acted as a substitute for audio.  Well-timed notes and speech bubbles made the video shorter. While these got the job done, I'm not sure more video tutorials with this limitation are worth it.  Because of the limited value of making new tutorials at all, I think I should call this latest one my last.  It's time to focus my efforts where they'll do the most good.

Losing Amazon Ads

There are no more Amazon ads on my site because I live in Connecticut.  My governor passed an affiliate sales tax law.  Amazon is now supposed to levy my state's sales tax if users arrive there via my site.  They didn't like it so they closed my account along with every other Amazon associate living in Connecticut.

This makes for an interesting problem.  To find a replacement affiliate program, I'd need something that dealt in books and computer hardware.  Also, they would have to be widely known and trusted.  Thirdly, they'd have to tolerate my state's affiliate tax.  That's a pretty tall order.  It's likely easier to figure out a business plan that doesn't need affiliate programs.

Moving Forward on Python Developments

The setbacks got me thinking more about writing code.  A better version of my animated mesh mangler now sits in the script section of my site.  I submitted my pyramid generator script to the Blender tracker for consideration in the next Blender release.  I've also started playing around with curves in the Blender API.  It'll be interesting to see how this all turns out.

What This Week Drives Home

The good thing about losing Amazon and my microphone is how it pushed me change priorities.  The transition from tutorial writing to development is complete.  For better or for worse, the teacher is a maker now.  Maybe the change was overdue.

Thoughts on Python, Marketing, and the Future

I have a confession to make.  I'm a better programmer than I am a business guy.  However, much of the focus last week was on marketing, design, and the business angle of Blender Python Tutorials.  Here is some of what happened and the conclusions I came to.


Marketing and Design

Advertising is a key component to marketing with Blender Python Tutorials.  Failure of past ads to generate revenue lead to changing to an approach based on text ads instead of graphical ones. More layout improvements with respect to ads may also improve the situation. Time will tell how effective this will be. However, even if it fails, the site design is still improved over what it was.

Knowing one's audience is also an important part of marketing strategy.  Time with the Blender Artists forum helps me better understand the concerns of other script developers. My posts include a tag line that links to my site which helps drive traffic. However, I only post when I have an answer to give or something real to share. Otherwise, I lurk quietly and listen.

The Business Plan Is Wrong

My business plan focused on training on a specific case of software-embedded Python. The idea was to make ad money on tutorials and the occasional example script. It failed.  Some research as to why was in order.

Here's what I noticed. Python is embedded in a lot of software projects. Blender, Inkscape, GEdit, Houdini, and Gimp are a few that come to mind. Those projects reaped the benefit of hundreds of extensions and plugins. These improvements may not have happened to this magnitude had the developers not made the decision to embed Python into their code bases.

However, a few Google searches on tutorials for Houdini Python, Inkscape Python, and so on produced some interesting results. Results ranged from single blog posts to master classes. What I did not find were successful businesses based solely on script training for a specific application.

There is a reason for that. Once you know a programming language, any good developer will pick up what they need as the need arises. This isn't to say tutorials are a waste of time. However, most learning comes from looking at examples and API references, asking questions, and writing your own code.

The Future of Blender Python Tutorials

My time spent working on Blender Python Tutorials was worth it. The site is a good resource and I'm a better programmer for having done it. It's also my way to give back to the Blender community that made such an excellent 3D package free for me to use.

However, there is only so much further my tutorial site can go. There is still more Youtube work to be done. Aside from that, the focus will shift more to developing software that's useful and solves real problems. Come to think of it, there might be a business plan in that.

Animation, Legacy Code, and Javascript Challenges

Intro

Getting turned down for a job stinks because rejection stinks. Then again, fertilizer also stinks but it helps things grow. In that sense, rejection is a character builder. Besides, if better web developers than me weren't getting hired to work at some of these companies, there would be no CSS or Javascript examples to "view source" on. Patience may be a virtue but it sure is nice having projects to make that virtue attainable. So let's talk projects.

Animangler

The Mesh Mangler script roughs up 3D meshes by moving the vertices in random directions to one extreme or another. Animangler is basically the same script but with an animaion focus. By creating shape keys and mangling those, it makes it easy to animate weird floating blobs that morph in interesting ways. It's a pretty simple script thanks to the hard work that Blender developers do to make these APIs available for people like me to play with.

Legacy Blend

Getting boring chores out of the way is liberating once done. That's the best way to describe the process of updating tutorial files and making blend files for the old Blender 2.49 tutorials. Occasionally, people do still make inquiries in the Blender Artist forums about that API which makes it worth keeping those old tutorials around awhile longer.

A Cleaner Uncle Squirrely Front End

The Uncle Squirrely project would be better if it's front end code was free of server side PHP logic. It's a very doable task given the right mix of Ajax, JQuery, and JSON. However, it's also a challenging project that pushes my own limits. This limit pushing is a good thing for me as a developer.

The Coming Week

The coming week's challenges will be a continuation of Javascript research, getting hands on with practical Internet marketing and more Python work. Since I'm still in the running for a Django position at a startup, it works out to be one of those good investments that I'd have ended up doing anyways. Will talk later. Cheers all!

C#, MySQL, and Inteview Fun

This was a crazy week. Two job interviews and tech projects kept me going quite a bit. Here's the story.

Reacquainting with .NET.

Since one of the jobs was for C# and ASP.NET, a refresh was in order. The first C# program took half an hour and covered features taught in an Intro to programming course. The ease of refresh was thanks to the fact that Python and Java has many of the same features C# has.

ASP.NET required setting up an XSP development server and writing some quick “code behind”. It was like writing VB form code but with C#. That much was easy. Figuring out how to deploy was harder. Getting C# talking to MySQL was hardest of all.  Finishing that one can wait.

End of the MySQL Stored Procedure Experiment

Speaking of MySQL, the stored procedure experiment came to a successful conclusion. I buried both SQL code and logic that was in PHP in the database. While burying a single query in a stored procedure offers no performance gains, there are other benefits for the Uncle Squirrelly project. The PHP code is cleaner and the overall application is more secure. Despite these gains, However, I still have no intentions of merging that git branch. If it ever went back in production, MySQL permissions for stored procedures could become an issue.

Better CSS Menus

Studying the source of other web sites brought to my attention a better way of handling menus in Blender Python Tutorials. Combining unordered lists and CSS makes for a nicer menu setup with consistent control of margins and padding. Another site had a CSS text rollover effect that also got implemented.

So that was my week. It was job interviews and tech work and I had fun. I look forward to more interesting things in the coming week.

Site Design, Video Tutorials, and Mesh Mangling

I got a lot done this week.

On Site Redesign

First off, I redesigned the site. I replaced the table layout with div tags and CSS positioning. I also put in graphics, rounded borders, and a few other changes to the overall site look. It looks a lot better.

On My First Video Tutorial Screencast

I posted a Hello World video tutorial to youtube and the web site. It wasn't easy. Being on Ubuntu meant figuring out XvidCap, Sound Recorder, Audacity, and Avidemux to get the job done. The final result isn't perfect because of the stick mic I used. Thankfully, Youtube made getting it online and on the site the easiest part.

On Mesh Mangling and Creativity

I made a simple mesh mangler tool. It moves around parts of a 3D object randomly and has a slider to control how badly you want it to be messed up. It's a good way to make things look beat up and broken. It can be used for crinkling paper or rumpling up cloth for example.

My motivation for the mesh mangler is I wanted to move beyond tutorials and just make stuff. So I figured I'd do a small project just for fun. Example scripts is where I want to take Blender Python Tutorials down the road. Tutorials are generally a good way to start off but I think experimentation, curiosity, and learning from others is a better way to learn in the long run.

Making Decorators and Taking Advice

Decorators for Web Service Data Collection
There are a lot of funny things that can happen when pulling web service data for the Uncle Squirrely project.  Connections failures, page mismatches, or general web service errors can hit without warning.  These can cause my database update scripts to crash and burn. 


Because of the apparent randomness of the errors, the best response is to make reattempts.  This requires a "re-attempt" loop.  The problem is that wrapping these loops around existing logic and exception handling can be messy.

This is one area where Python decorators shine.  With a decorator, I can wrap the entire web service method into a separate object that takes care of the reattempt business for me.  That way, I can give random connection failure a second or third chance to recover without having to clutter up the code.  The RecoverWSExceptions class I wrote was extremely useful in keeping this all clean for me.

Blender Python Tutorials Advice
I asked the Blender Artists community what I could do to make Blender Python Tutorials better.  Their advice was to add blend files and screencasts.  Adding blend files was easy.  It was just a matter of creating the files, adding code, and modifying things to ensure they would work with the new Blender 2.57 release.  Piece of cake.

Screencasting, on the other hand, is hard.  The Ubuntu tools I found were pretty quirky.  The good news is I was able to work through a lot of the technical hurdles for using tools like Audacity and XVidCap.  I guess it's one of those things that are inevitable when you start getting more serious about 3D.  At some point, you're going to have to wear that a/v engineer hat.

And then there's the part I play the performing artist and step up to the microphone.  Doing a good verbal performance is hard.  I've cranked out 3 attempts at the "Hello World" tutorial and I'm not satisfied with any of them so far.  It made me respect performers great and small who put themselves out there doing that for a living.

 So that's about it for now.  It definitely was an interesting week and hope to get new stuff out this week.  Cheers.

Open Quarters - An Interesting Flow Trick

Here is a time management technique I've been using lately. Grab a timer and set it for 25 minutes. Write down something to do for that period of time. Activate the timer and focus on the task and nothing else. When the timer goes off, stop if you want to.

This is a lot like the Pomodoro Technique. However, the difference between Open Quarters and Pomodoros are that you have the option of continuing your line of thought instead of taking a break. This leads to less procrastination, less self-consciousness, and loss of a sense of time. In other words, it promotes flow.

Let's look at procrastination. If you don't obligate yourself to working for more than 25 minutes, then starting is easier. It's hard to start on something that takes hours to do. Committing to a shorter period is easier and less intimidating.

It also helps beat back self-consciousness. With permission to quit after 25 minutes, there's less reason to judge yourself. You only go beyond that interval because you want to, not because you have to. And if it doesn't become interesting, that's fine too. Don't force yourself.

Last to consider is time sense. The problem with the Pomodoro Technique is time is never far from your brain because a timer going off every 25 to 30 minutes reminding you of it. In an open quarter, the timer goes off once and then stays out of your way if you choose to go on. However, if you do choose to continue, you'll be surprised how much time flies as a result of a project becoming fun and interesting.

I hope the Open Quarter technique helps you focus on your own endeavors as it did in helping me write this blog entry. And without further ado, it's time for you to close the blogs, set the timer and agenda, and get back to work.

Math, Amazon, and Android

Last week was a good one for math and dabbling. Here's a quick review of what happened.

Khan Academy Magellan Badge Victory

Acquiring the 80^th star completed the Magellan badge mission. Calling it satisfying would be an understatement. With that, it is time to stop collecting stars and just maintain the ones I have. Regular visits to the site to refresh here and there is sufficient for that.

Deeper into Amazon AWS Territory

The Amazon AWS cloud has interested me since working with it for the Uncle Squirrely project. A recent conversation with a friend drew me into S3 storage and Elastic Cloud virtual servers. It was time to go a step beyond web apis.

S3 is a handy way to backup and share files. It gives you permission controls that let you render certain files publicly available or not. Drop Box uses S3 to provide regular end-users with a simple interface. It's great for online storage which can be pretty handy.

With the Elastic Cloud Computing platform, Amazon offers up an easy way to roll your own virtual Linux or Windows 2008 server. There were a few small snags during my setup and connect attempts to Linux instances. After a short learning curve, it really was simple to start, stop, and kill servers as well as ssh into them.

The pay-as-you-go setup is perfect for me. An afternoon of playing around with a server and then killing it at the end costs 50 cents. However, for 24 x 7 production servers in the cloud, it gets pricey. In such case, a service like Rackspace would likely make more sense.

Android Adventures

Getting started with mobile development with Google Android proved to be pretty painless. Good documentation and tutorials made it easy to setup Eclipse, the SDK, and an emulator. It's been predicted by a couple of tech pundits that mobile was going to be big in 2011. The downside for me is finidng the tie-in to my main project. The upside is there's probably no better platform to go to if I were to go back into Java game programming.

All said it was a good week for intensive math goal pushing as well as with cloud and mobile dabbling. The next week shifts attention back more towards taking care of Blender Python Tutorials. The site is doing fairly well but it would be way better. So off to that then.

Skill Testing, Blender, and Google

Let's just get straight into what's been happening over the past week or so.

Blender Pyramid Script Upgrade

The step pyramid from my github is now upgraded to work with Blender 2.56. The big challenge was adjusting to changes to a new and better way of organizing vertices passed in via Python data. Hopefully, these API improvements will stabilize to make script development easier for me down the road.

Staffing Agency Interview

Last week's job interview with a staffing firm proved interesting. For one, the interviewer is an active Twitter user. For another, it was followed by computer-based testing on J2EE. 

The test results were odd. Despite my Java database background, my JDBC score was 0%.  On the other hand, lack of Struts experience didn't prevent me from scoring 100% in that area.

The big takeaway is my J2EE skills are rusty. Dropping PHP in favor of JSP might impact hosting and CMS options. As for my projects, little would really need to change.

Google App Engine

A tutorial on the Google App Engine introduced me to new tricks for web application development. It's pretty sweet. Java code can be compiled to Javascript. There are hosting options on Google. The near automated log on mechanism is nice. It also turns out that Khan Academy likes to use it.

Khan Academy Badge Chasing

Speaking of which, the Khan Academy star count is 74 at the time of this blog entry. 80 stars gets me the Magellan sun badge. More brush up on trig, calculus, and word problems should take me over the top.

Why do this? First off, in computer graphics programming, math skills matter. But the big bet is that earning that badge will land a job like no vendor certification can. It seems just crazy enough to work.

Plans for the Week

The rest of this week will be a final push for the Magellan badge. Plenty of job hunting to do as well. There will also be some neat experiments in Python and Java too. Never a dull moment.