Raspberry Pi: feeling geeky!

So a new experience with RaspberryPi, Linux, SSH and connectivity!

Purchased RPi and got it initially configured. Ethernet into router, browse web, perform basic shell commands. Then moved to iMac OS X terminal window with SSH for even more sophistication. With RSA keys, the SSH just works very smoothly.

Then configured for home Wifi and tested with Attachmate’s Reflection terminal emulator. Works great! iPad to Linux console; I’m not sure this is totally kosher, but taking chances here.

Then off to Windows 7 with Putty and SCP, yep that works pretty easily enough as well.

Time to get fancy. Shutdown home router and fired up iPhone Personal Hotspot. Configured RPi to accept that. Connected from iPad to RPi via iPhone: yep, that works as well.

Finally, just to impress my wife (NOT), I installed Reflection on iPhone and, sure enough, I now have iOS with terminal emulation to Linux console.

When does the geekiness stop?

Raspberry Pi: feeling geeky!

Expert Beginner Advice

See Eric Dietrich’s column on the definition of Expert Beginners. His article documents how *badly* advanced beginners can hurt your organization.

Recently an expert beginner argued that it’s better to duplicate strings than to risk changing them to a #define implementation. To 2x-check this, a simple program was created:

#include “stdafx.h”
#include <string>
#define FOO “foo”

int main()
{

std::string a1(“abc”);
std::string a2(“abc”);  //Purportedly the optimum practice
std::string f1(FOO);
std::string f2(FOO);//In-efficient practice according to expert beginner
return 0;

}

Disassembly:

int main()
{
… MS setup trimmed…

std::string a1(“abc”);
00C84C80 68 44 C1 C8 00       push        offset string “abc” (0C8C144h)
00C84C85 8D 4D D0             lea         ecx,[a1]
00C84C88 E8 E4 C5 FF FF       call        std::basic_string<char,std::char_traits<char>, rest of constructor trimmed…
00C84C8D C7 45 FC 00 00 00 00 mov         dword ptr [ebp-4],0

std::string a2(“abc”);
00C84C94 68 44 C1 C8 00       push        offset string “abc” (0C8C144h)
00C84C99 8D 4D AC             lea         ecx,[a2]
00C84C9C E8 D0 C5 FF FF       call        std::basic_string<char,std::char_traits<char>…
00C84CA1 C6 45 FC 01          mov         byte ptr [ebp-4],1

std::string f1(FOO);
00C84CA5 68 48 C1 C8 00       push        offset string “foo” (0C8C148h)
00C84CAA 8D 4D 88             lea         ecx,[f1]
00C84CAD E8 BF C5 FF FF       call        std::basic_string<char,std::char_traits<char>…
00C84CB2 C6 45 FC 02          mov         byte ptr [ebp-4],2

std::string f2(FOO);
00C84CB6 68 48 C1 C8 00       push        offset string “foo” (0C8C148h)
00C84CBB 8D 8D 64 FF FF FF    lea         ecx,[f2]
00C84CC1 E8 AB C5 FF FF       call        std::basic_string<char,std::char_traits<char>…  return 0;

}

So the expert beginner argued that re-defining “abc” as a #define was introducing a global variable in the program space. Therefore, it was more efficient to duplicate the constant.

Obviously, this is a unique perspective on computing and is completely wrong. The definition of #define from the original C days is for the pre-processor to replace the strings prior to compilation. The simple test program here illustrates that modern compilers recognize and can correct much of what may have been the case some decades ago.

What is interesting about this example is how wrong an expert beginner can be. Note how much research and experimentation is necessary to test & correct this error in logic. Experimentation is very helpful!

Expert Beginner Advice

Part 3 of 3 – Stagnant Company Culture

It’s said experience is what you get when you didn’t look for it. Even if you’ve worked for a brain-dead company, you can learn (if sanity doesn’t leave your mind first!)

So what are the consequences of a top-down, friends of the CEO, no growth, lack of training, no-risk company?

It’s not un-common for the lack of executive talent to reduce management to nonexistent competence at the lowest levels. The resulting CYA perspective will absolutely destroy initiative. When the trained expectation is that they will be told when, where & how to jump, it’s not reasonable to expect that they would “drive” items to resolution. Ie, pick up the phone and walk a work item through final delivery. In other words, the minions will do exactly what they are told and nothing more.

In fact, the minions have had any & all initiative destroyed to the point, they can’t conceive of another way to perform or contribute. Regardless of what they do, someone may “yell” at them. Ouch, that hurt my feelings! If no initiative is taken, there isn’t the risk of a screwup. Of course, without *some* failure, there isn’t any learning. Without learning, the recursive nature of brain-deadness is exponentially devastating.

Oh, you expect the minions to think big? Consider the long-term consequences of decisions? This responsibility is completely delegated back to the management team. Of course, with each deferment up the chain, the decision maker is further from the truth.

Many writers discuss partial agile implementations of software development. To me, if the company culture precludes risk, initiative, reveres technical or managerial orthodoxy, then you’re struggling. Agile benefits will continue to escape the organization and the team. Life is decidedly a drag.

What happens if one’s career is based on this single failure point? As always, it depends. In health care, 1 morbid disease is survivable, 2 diseases are survivable; 3 is not good. So if you’ve fulfilled parts 1, 2 & 3 of my rants, chances are slim that you find agile software processes attractive.

Erik Dietrich’s article “http://www.daedtech.com/how-developers-stop-learning-rise-of-the-expert-beginner/“ is a great article of the end-state of such a life experience (parts 1, 2 & 3.) The combination of these parts can contribute to the expert-beginner syndrome.

Part 3 of 3 – Stagnant Company Culture