I just finished up the book Ikigai (or rather, ordered collection of essays, email fragments and blog posts) by a guy named Sebastian Marshall.  Ikigai translates to “Reason for Living,” and Sebastian does a good job of putting together a case for what type of reasons one should live their life, and provides a general framework for doing it effectively.  The book constantly reminded me of work I’ve read by the Stoics (ie Marcus Aurelius, Cicero, and Epictetus).  I wouldn’t go so far as to put Sebastian’s work on an equal footing with Marcus Aurelius’ Meditations, but it is good.

The book covers a lot of ground for being a short read.  I finished in a week of  reading one hour per day.  Among the topics discussed:

- Why it pays to study history.  He includes tons of historical examples of figures who made both strategic strokes of genius and blunders.

- Managing your life.  The importance of tracking things.  Sebastian contends that what gets measured gets  managed, so if you want to stop a bad habit or create a good one  you need to start by tracking how much you do it.

- The importance of constant learning and self enrichment.  Why you should pursue all of your interests (yet carefully schedule that pursuit, thus eliminating all but the most important).

- Settings goals and getting things done.

- Self control and self discipline.  How to build them.

- The low value of temporary happiness and the high value of producing great work.

- Why the “All you have to do is find your passion!” stuff is mostly bullshit – sure you can’t hate what you do but no one who achieves anything does it without doing things that are hard.  For example, I don’t enjoy every line of code I write, nor am I *always* enthused about studying new programming techniques.

The book is by no means perfect.  There are many sentence fragments, a few misspelled / cut off words, etc.  It was not proofed well.  It is not polished, and as something of an English language snob, at times it annoyed the hell out of me.  However, it is a great read.  It’s inspiring, funny, and you’ll definitely learn something.  At times I found myself saying “HELL YES” and pumping my fist.  I rarely do that while I’m reading.

If I had to produce one paragraph that aptly described Sebastian’s message, it would be this:

“You’re going to DIE some day.  Don’t waste your life  mucking around in mediocrity.  Don’t  compare yourself to peers in your own generation – compare yourself to the greatest in history.  Put yourself at the bottom of THAT mountain and start climbing.  On your journey upwards, take care of your body, constantly feed your mind, and be a Johnny Appleseed.  Help others when you can, and do not grant that help begrudgingly.  What are you waiting for, go out and start doing things.”

Check out reviews on Amazon

Arithmetic operators

Ok, lets roll through these as fast as we can. You know these, right?

+ for addition
- for subtraction
* for multiplication
/ for division
% for modulo (remainder after two numbers have been divided)

You can use each of these operators to work with numeric data types (examples in C – int, float, and double are all numeric data types):

//Addition
int x = 2 + 2; //4
int x = 2.0 + 2; //4;
float x = 2.0 + 2; //4.000000

//Subtraction
int x = 2 - 2; //0;
double x = 2.0 - 42; //-40

//Multiplication
int x = 2 * 2; //4

//Division
int x = 3 / 2; //1
double x = 3.0 / 2; //1.5
double x = 3 / 2; //1.000000 <- Be careful with these!

//Modulo
int x = 5 % 4; //1
double x = 3.0 % 2; //Won't compile, actual sanity check here!

Relational (also called comparison) operators

These operators are used to compare values. In all languages they can compare numeric types. In most languages they can compare strings and characters as well as simple datatypes (such as enums). In some languages they can compare more complex data types such as vectors, arrays, and objects.

>= greater than or equal to
> greater than
<> not equal to (less than OR greater than)
<= less than or equal to
< less than
!= not equal to
== equal to
=== equal and same type (PHP)

Python:

3 >= 4 #False
4 > 3 #True
"test" <> "test" #False
"apple" != "orange" #True
"3" == "3" #True

PHP:

$arr = array();
$arr2 = array();
var_dump($arr == $arr2); // bool(true)

$obj = new StdClass;
$obj2 = new StdClass;
$obj->apple = 'test';
var_dump($obj == $obj2); //bool(false)

var_dump(3 === "3") //bool(false)

Logical operators

&& and
|| or
! not

Increment and decrement operators

Pretty simple, like the arithmetic operators…

++var //Increment, equal to var + 1
–var //Decrement, equal to var – 1
+= //Add one number to another
-= //Subtract one number to another

var i = 1;
++i; //2
--i; //1
i += 1; //2
i -= 1; //1

Assignment operators

= //Assign a value
+= //Compact assignment, addition, equal to x = x + y
-= //Compact assignment, subtraction, equal to x = x – y
*= //Compact assignment, multiplication, equal to x = x * y
/= //Compact assignment, division, equal to x = x / y
%= //Compact assignment, modulo, equal to x = x % y

Bitwise operators

& //True if any is true. Evaluates to last statement (meaning all conditions are checked).
| //True if either is true.
^ //True if only one is true.
<< and >> // Left shift / right shift operators. Perform shifts at binary level.

Note that & and && are different in that && “short circuits” if one of the conditions it’s evaluating or false.  Consider the following example:

#include "stdio.h"

int printSomething()
{
	printf("%s", "Something");
	return 1;
}

int main()
{
	int x = 3, y = 2;

	int a = (x > y & y > 5 & printSomething()); //"Something" is printed

	int b = (x > y && y > 5 && printSomething()); //"Something" is not printed.  && operator short circuits and after y > 5 evaluates to false conditions stop being evaluated.

	printf("Example 1: %d \n \n", a);

	printf("Example 2: %d \n \n", b);

	return 0;
}

The | operator is the same as the &, but does OR comparisons.

The ^ operator evaluates whether or not ONLY ONE of the conditions is true:

#include "stdio.h"

int main()
{
	int x = 1, y = 2, z = 3;

	if(y > z ^ x > y ^ x > 0) printf("%s \n \n", "True!"); //Only one condition is true, statement evaluates to boolean true

	if(z > y ^ x > 0) printf("%s \n \n", "Also True!"); //Both conditions are true.  Statement evaluates to boolean false and "Also True!" is not printed

	return 0;
}

Shift operators work at the binary level. Easy way to raise any multiple of 2 to the nth power:

#include "stdio.h"

int main()
{
	int x, z, y = 2, a = 3, r;

	x = y << 2;  //Binary operation.  Bits are shifted two places to the left (001 becomes 100).  This evalutes to 8

	printf("%d \n \n", x);

	z = a << 2;  //Binary operation.  a starts as 011 and bits are shifted two spaces to the left.  a becomes 1100 (12)

	printf("%d \n \n", z);

	r = z >> 2;  //Binary operation.  r shifts z to spaces right.  r is 3.

	printf("%d \n \n", r);
}

Ternary

Seeing this freaked me out when I first started programming, but it’s actually really easy.

#include "stdio.h"

int main()
{
	int x = 1, y = 2, a;

	a = (x > y) ? x : y; //IF x > y, a = x, ELSE, a = y

	printf("%d \n \n", a); //a is equal to y
}

Other operator uses (strings, arrays, objects, etc.)

. //Dot notation for concatenating strings, not to be confused with dot notation like calling a method in ruby or python
+ //Used for concatenating strings. In some languages more complex data types can be joined.
+= //Add one string to another
.= //Concatenate strings
&= //Reference assignment

PHP

$string = 'test';
$stringtwo = 'test2';
$concat = $string . '  ' . $stringtwo; // "test test2"

$concatTwo = '';
$concatTwo .= $string;
$concatTwo .= $stringtwo; //test test2

$ref &= $string; //"test"

JavaScript

var myString = 'test';
var mySecondString = 'test2';

var concat = myString + mySecondString; //value is testtest2

Python uses the same concept:

test = "test"
maybe = "tester"

test + maybe # 'testtester'

In PHP associative arrays can be joined with the + operator. It’s not a good idea to add arrays with numeric keys because only one value will be retained:

$one = array('test');
$two = array('test2');

$three = $one + $two; //$three is now array('test');

$four = array('test' => 'tester');
$five = array('tester=> 'tester2');

$six = $one + $two; //$six is array('test' => 'tester', 'tester' => 'tester2');

At least in the languages I know a bit about, the -. *, % and / operators cannot be used on any non-integer types.

That’s all I got. Hope you learned something!

One bit that tripped me up were what looked like functions, but were actually macros (I later learned these are called macro-like functions).

Now, I know C is an ancient language and I’m sure this has been discussed thousands of times (or more) – but I still think it warrants a blog post. So here is a macro-like function:

#define squaredM(x) x*x

And here is a function:

double squaredF(double x)
{
    return x*x;
}

Here is what looks like the same code calling functions that do the same things:
double ans = 18.0 / squaredM(2+1);
double ans = 18.0 / squaredF(2+1);

You might assume that both pieces of code would be handled the same way. And you’d be wrong. I did not assume that both pieces of code would be handled the same way, but I also made an incorrect assumption how a function-like macro worked (I did not already know). The key difference is that a function-like macro is pre-processed and then compiled, while the function is compiled. In plain english, that means that when you compile the program, the preprocessor essentially creates a new piece of code, with the macro substituted in, and then compiles:

double ans = 18.0 / 2+1*2+1;

Order of operations tells us that division / multiplication, left to right, should happen first. So you actually end up with 9 + 2 + 1.

In the second example, using a function, 2+1 is already a float of 3.0 when it is received by squaredF. This may not ever be useful to you, but I thought it was cool and wanted to share it.

References:
Wikipedia (C Preprocessor)
IBM AIX Compilers Reference
MIT Open Courseware Answers

So, let’s start simple. Take the following example (it’s in PHP, but you will find EXACTLY the same behavior in ANY language that uses the static keyword on variables – the concept itself is inherited from C):

function test(){
	$test = 0;
	$test += 1;
	return $test;
}

echo test(); //1
echo test(); //1
echo test(); //1

What’s expected, right? Ok, now throw a static in front of the declaration for $test

function test(){
	static $test = 0;
	$test += 1;
	return $test;
}

echo test(); //1
echo test(); //2
echo test(); //3

Trippy, right? When a variable is declared static, it’s stored in the program’s memory for the duration of the program’s runtime (translate for web devs: from the point the static var is created till the request has finished and the page is loaded). In this case, $test is only available within the scope of the test() function, so it isn’t global, but within the scope which it was declared – it persists until the program ends.

Ok, now let’s look at how the same idea applies to classes:

class StaticTest {

	public static $test;

	public function __construct()
	{
		self::$test = 'hello';
	}

	public static function getTest()
	{
		return self::$test;
	}

	public static function setTest()
	{
		self::$test = 'test';
	}

	public function __destruct()
	{
		echo "StaticTest class is dead \n";
	}
}

class Tester {
	public function __construct()
	{
		new StaticTest();
	}

	public function __destruct()
	{
		echo "Tester class is dead \n";
	}
}

new Tester();

echo StaticTest::$test . "\n \n";

The previous example may remind you of the Singleton pattern. The important distinction to be made is that in this example, no instance of StaticTest exists when StaticTest::$test is called at the end of the program. StaticTest is instantiated by Tester, sets a static variable, and then dies. Tester is instantiated, and then dies. The static member of StaticTest itself lives on, and is still available, regardless of whether the class instance which created it is alive or not. Singletons are different because proper Singletons store their static properties privately. Thus, if the Singleton was killed (which, I’ll grant you, presents it’s own set of challenges), it’s members would no longer be accessible, even though they do still exist in memory.

To sum up, a public, static property of a class is generally equivalent to a global property, and thus violates encapsulation. Thus, their implementation within a class interface should be carefully considered. A static variable within a function persists within it’s own scope for the duration of the program’s runtime.

High Level Overview

The observer pattern does exactly what it sounds like it should do – it allows one class to observe the changes made in another. Essentially, you have a class or set of classes (the subject), that inherit an abstract interface which will dictate the methods that they must implement in order to provide updates to their observer(s). The subjects don’t actually do the talking to their observers directly; there is always a layer of abstraction to ensure the subjects and observers are decoupled.

Coming from a web programming background, it may not be immediately apparent why the observer pattern is especially useful. This is because (in my opinion) web programs (with some exceptions) tend to have a very short runtime (meaning their execution starts when you load a page and concludes when the page finishes loading). So, even though we use the observer pattern in web programming (MVC springs to mind), I don’t think it’s usefulness and role are as readily apparent as in other contexts. In programs which are “on” until they are intentionally shut down (ie programs that run on an event loop, main loop, etc.), the importance of this pattern is much more obvious.

Here are some real world examples:

- The observer pattern forms the basis for how many GUI frameworks operate. It was first introduced in the SmallTalk language, which had an extremely strong influence on Apple and the evolution of their Objective C language. Many of the programs you use every day implement the observer pattern. Qt framework (c++), a GUI framework developed by Nokia, implements the observer pattern for Signal and Slot events – ie so your program knows when a button is pushed and can hook that update to the appropriate class / method. Java likewise implements a very similar signals / slots mechanism.
- Your web browser implements the observer pattern. You know that thing the DOM? Event listeners? onSomething(doThis)? Yea.
- Your cell phone implements the observer pattern. Your phone is always sitting there…waiting…just waiting for the network to tell it there is an inbound call.

…There are tons of other real world examples. At it’s core, the observer pattern is just a standardized way of separating cause and effect to reduce dependencies within a system. I hope this has been a decent beginner’s introduction!

Resources (best I’ve found)

Source Making: http://sourcemaking.com/design_patterns/observer
IBM Research: http://www.research.ibm.com/designpatterns/example.htm

If you search for ‘Singleton’ in Google or StackOverflow you get a bajillion and a half results.  That makes sense, because it’s one of the most commonly implemented design patterns in the history of software.  Some reasons for the popularity of the Singleton are:

A.  It makes more intuitive sense to store things you want global access to in well-defined groupings, instead of having a bunch of globally namespaced functions, constants and variables you need to keep track of (read more about namespacing here).

B.  They are incredibly easy to implement.

Stick with me, by the end of this post you’ll have a much better understanding of the Singleton, and links to some other great reference materials.

So what are Singletons, exactly?

As you may know, computer science inherits a great many ideas from mathematics, and if you want to become a better programmer – and hope to someday call yourself a computer scientist, you must understand the mathematical foundations on which computer science has been built.  Fortunately, most of the concepts are pretty easy, including the Singleton.

A Singleton, as defined mathematically, is a set (a set could be similarly described as an array, linked list, vector, etc.) which has a cardinality of 1, meaning it only contains a single tuple, and that it cannot be subject to injective functions.  In plain English, this means that a set is only a Singleton if it:

A.  Only has one root level element.

B.  Has no siblings.

C.  Can not be cloned.

If it does not meet these requirements, it is not a Singleton.

As programmers, we commonly associate Singletons with single class instances (single objects), but they could also be other data types as well.  For example, some languages, such as Delphi, C# and Charm++, allow for read-only arrays, while C++ allows you to declare arrays and vectors as constant.  I’m sure there are many other examples.  I believe (though someone may correct me on this) – that those would also qualify as Singletons using the mathematical definition – provided they meet the aforementioned requirements.

Common uses of Singletons

Singletons are usually used by programmers when they want a class instance that is truly global – meaning that various classes and functions can perform operations on the instance, and see the changes the others make, without the need to pass a reference to that class around.

A. Logging: As opposed to procedural functions in the global namespace, “Logger” classes are commonly implemented as Singletons.

B.  Truly global classes: For example, keeping state.  Session and authentication management come to mind.

C.  Database instances: Singletons can in some cases reduce memory usage in your application because a single connection point to the database is established; a new instance is not created each time a query is made.

I’d love to hear some of the ways which you have implemented Singletons with satisfaction.

Criticisms

But what is a pattern if not also a suspected anti-pattern?  Singletons, despite their heavy usage, certainly have a fair amount of haters out there.  Some of these criticisms are simply FUD (fear, uncertainty and doubt) being passed from programmer to programmer like gonnorhea in a co-ed dorm; however, some are valid, and certainly need to be factored into design decisions.

A.  It’s hard to destroy a Singleton, and mishandling can cause very subtle and perhaps disastrous results.  Say, for example, that you want your program to destruct (shut down) in a very specific way.  You can’t really have a class destruct the Singleton, because hey, if the only class that can MAKE a Singleton is the Singleton itself, why should another class be able to destroy it?  And what happens if the class that destroys it kills it before another class, also dependent on the Singleton, can use data it depends on?  This rules out having other classes destroy Singletons.  So how about self destruction?  Well, depending on the language, compiler, and other variables, you may not have any control over what order objects are destroyed in.  When you only have one Singleton, this probably won’t cause an issue, but if you have many Singletons, each of which may depend on the data of the other, you may create the same problem faced in the previous example – you have dangling references to things that don’t exist anymore.  Not good!

This barely scratches the surface of this topic, for more I’d check out this article by John Vlissides, one of the original “Gang of Four” members, who spent most of his career as a researcher at IBM.

B.  Singletons can make testing, reuse and debugging painful.  Remember, since there is only one instance of a Singleton, if one class makes a change to a Singleton member – all other classes that use that data are now using that updated value.  Misko Hevery has written an amusing post on this topic here titled “Singletons are Pathological Liars.”

C.  Inheritance.  By definition, singletons cannot be used as base classes (ie child Extends Singleton).  However, some languages (such as C#) which support nested types.  Check out this post by John Skeet, a prominent C# developer and the author of “C# In Depth”, for more info on that.

Singletons and multithreading

Threads are spawned within the process created when a programming runs.  Multithreading allows a program to essentially “splinter off” and go in multiple directions simultaneously.   Concurrency problems occur when these threads are accessing shared resources and happen to collide.  One of the most intriguing bits I’ve read about Singletons was written by Vishal Kochhar.  He explains why the standard approach to Singletons is not threadsafe, and how mutual exclusion (a concept introduced by the late Edsger Djikstra, the Dutch computer scientist  who also gave us the modern pathfinding algorithm) can be implemented in C++ classes to ensure thread safety.  The article delves into many cool things – and I highly suggest you check it out.

Most scripting languages tell you that you need not worry about thread safety – that the language designers have ensured it – but if I was working on code that depended on thread safety, and was using Singletons, I’d probably double check. You need not worry about this in languages that do not use threads (such as JavaScript, unless you are using Web Workers – which DO in fact spawn threads).

Implementation in three languages

I implemented a Singleton class in 3 languages for fun and learning.

C++

#include <iostream>
#include <thread.h>

using namespace std;

class Singleton
{
	public:
		static int val_;
		static Singleton* instance() {
			if( val_ == 0 ) {
				//lock_mutex();
				if(p_instance == 0)
					new Singleton;
				//unlock_mutex();
				//MEMORY_BARRIER();
				val_ = 1;
				return p_instance;
			}
			else {
				return p_instance;
			}
		}

		void setMember(string& newState) {
			m_member = newState;
		}

		string getMember() {
			return m_member;
		}

	private:
		Singleton(){}

		static Singleton* p_instance;

		string m_member;
};

Singleton* Singleton::p_instance = 0;

int main()
{
	string newState = "active";
	Singleton::instance()->setMember(newState);
	cout << "Member has been set to:" << Singleton::instance()->getMember() << "\n";
	return 0;
}

Please note that the ideas for mutual exclusion were taken from the article written by Vishal Kochhar, which I have referenced.

JavaScript

var Singleton = (function()
{
	var instance = false;

	/*
	* Because this is in a closure, it cannot be accessed
	*/
	var member = 'test';

	function Constructor(){

		this.getMember = function(){
			return member;
		}

		this.setMember = function(v){
			member = v;
		}

	}

	/*
	* This is what's actually returned by the closure
	*/
	return new function(){

		this.getInstance = function() {	

			/*
			* Private member functions are accessible once the constructor has been called
			*/
			if(instance == false){
				instance = new Constructor();
				instance.constructor = null;
			}

			return instance;
		}

	}

}
)();

//print(Singleton.getInstance().getRand());
Singleton.getInstance().setMember('whatuppppp');

print(Singleton.getInstance().getMember());

Please note that this JavaScript implementation is almost certainly not a "real" singleton - it can be copied and passed around.

PHP

//Shows how a singleton can be used to keep state for the duration of a request
class Singleton
{
	private static $instance = 0;

	private static $member = null;

	/*
	 * Private constructor prevents object initialization ith new keyword
	*/
	private function __construct(){}

	/*
	 * Creates an instance - accesed statically since constructor is private
	*/
	public static function instance(){
		if(self::$instance)
		{
			return self::$instance;
		}

		//Return a new instance if one does not exist
		return new Singleton;
	}

	public function setMember($v){
		self::$member = $v;
	}

	public function getMember(){
		return self::$member;
	}

	/*
	 * Prevents cloning (ie copying the instance or using the clone keyword)
	*/
	public function __clone(){
		trigger_error('Singleton instance cannot be cloned.', E_USER_ERROR);
	}

	/*
	 * Prevents Unserializing of Object
	*/
	public function __wakeup(){
		trigger_error('Singleton instance cannot be unserialized.', E_USER_ERROR);
	}
}

class A
{
	public function __construct(){
		Singleton::instance()->setMember('active');
	}

	public function __toString(){
		return Singleton::instance()->getMember();
	}
}

class B
{
	public function __construct(){
	}

	public function __toString(){
		return Singleton::instance()->getMember();
	}
}

//Class A sets the member's value to 'active'
$a = new A;
echo "Member after being set by class A: $a \n \n";

//Class B simply returns the member value set by class A
$b = new B;
echo "Member after being returned by class B: $b \n \n";

Conclusion

Singletons are a popular pattern with both benefits and challenges associated with them. If you want to make use of this powerful pattern, ignore anyone who treats them as artifacts in a religious war and focus on understanding what they are, why and how they can be used.

Disclaimer

This post is essentially self-assigned homework.  I've written it to increase my own understanding of Singletons, their uses, limitations and theoretical underpinnings.  I hope this has helped you, but also hope you verify any assumptions I may have made, and point out any mistakes.

1. Download dbase: http://pecl.php.net/get/dbase

2. Extract and cd into.

3. sudo phpize

4. sudo ./configure && sudo make && sudo make install

5. Add extension=dbase.so to your php config and restart apache.

Done!

So, basically your internet service provider (ISP) is going to give you a public IP address so that you can connect to the internet. Typically, an ISP will only assign you one IP. The internet is essentially just one huge network, and having an IP allows you to be in that network.

Yea, dude, you’re gonna need a firewall

Go to whatismyip.com and get your IP address. Copy and paste that IP address into your browser and see what you get. If you’re using a standard router, or are directly connected to the internet and are running a web host on your computer, you’ll see either your router’s login page or whatever content your computer publishes on port 80. The ramifications of your computer / server having an IP on the internet are that other computers can see you, just like you can see them. All those websites out there are just other computers (or clusters of computers).

A firewall is a device (either physical or virtual) that protects your computer / server from outside intrusion by filtering out what connections can be established. At the simplest level, this is done by opening and closing ports, and by deciding which IP ranges you will allow connections from. A good firewall setup will typically only allow connections on the ports that seem to have a good reason for being open. Some examples:

• Port 80 allows HTTP connections. This is how you browse the web
• Port 443 allows HTTPS connections. This is how you checkout securely in a website payment process
• Ports 22 and 21 allow for SSH and FTP, respectively, two ways of interacting with other computers (the former being total access, the second being file server access)

There are thousands of ports on a computer, many of them for unique processes you’ve never even heard of, some of them ready for you to assign a purpose to them. All of these ports give attackers MANY doorways to enter your network. Best practice is to only allow connection on the ports you need. Ports 80, 443, 22 and 21 would be pretty standard.

If you aren’t running a firewall – you are wide open. Once I get your IP address (and I could do that by scraping IPs from forums, or hell, even using nmap to try certain ranges and see who I can ping), if you aren’t running SOME type of firewall, I can own your bases. So make sure you include one in your network.

What your server does

Your server is probably the most important piece of your network. Beside the fact that it will be running all kind of software that your users need, it performs some very important functions just in keeping the network online. For example, your server can:

• Assign IP addresses to other machines on the network
• Share an internet connection and speed up your internet by circumventing your ISP’s DNS
• Provide an authentication mechanism for other machines on the network to use
• Facilitate cross-platform file and printer sharing
• Provide shared software to use across the network

Building your server

The great thing about Linux, derived from UNIX, is that it can run and perform fairly well on just about any hardware (you can even run UNIX on a gameboy, though I don’t recommend it here = )). You’ll be building what essentially boils down to a computer. Here’s what you’ll need:

• A motherboard
• A processor, heatsink and fan (the heatsink and fan that come with processors usually suck)
• RAM
• A hard drive
• A motherboard
• At least 2 ethernet devices
• A case (housing) for all of this to sit in)

Once you get all the gear, assembly is pretty easy, and is well documented elsewhere. The main thing to ensure is that everything is compatible with everything else. For example, your motherboard will support a specific chipset, so you need to choose either a motherboard or a processor and then getting a matching component. RAM types supported and the size of your hard drive (the physical dimensions, ie 3.5 inch or 2.5 inch) can vary too, so just make sure everything matches up.

Don’t feel like you need a CD drive to install the OS. You can easily load your OS from a USB drive or from the network.

Keep a backup!

Obviously, your server is your network’s lynchpin – and if it goes down it is really bad news…so make sure you have a backup. Lightning, hacking, or random hardware failure – you have to be prepared for it all.

I recommend building a secondary, much cheaper machine that you can quickly replace the more powerful version with if you absolutely have to. You’ll want to keep a daily backup of your main server so you can easily load the image onto your backup system.

The 802.1x switch

I didn’t know about this either, and when I asked about RADIUS server on ServerFault, I got flogged by experienced server admins for not knowing. 802.1x is a protocol developed specifically for handling network authentication. You can read a really good 802.1x overview here.

Unfortunately, not all networking devices support 802.1x, so you need to get one that does support it. Managed 802.1x switches start at a few hundred dollars and can get really expensive. I bought a ZyXel GS2200-24 and am really happy with it so far.

You’ll need to read your switch’s manual as it relates to creating LANs, enabling AAA / radius (802.1x), and port authentication just to get a basic setup rolling, but it should be too tough.

The patch panel

This is just a way to keep from looking at a nasty nest of jumbled wires going into your switch. Basically, you wire cables directly to the back of your patch panel (instead of using an RJ45 and plugging them in). Then, you run a short cable (under 6 inches) from the patch panel to the switch, and you label each port on the patch panel. This makes it really easy to keep track of where each wire goes, and to enable easier termination and troubleshooting.

This does mean a lot of extra wiring work, but it should be worth it.

802.1x Wi-Fi

With 802.1x enabled Wi-Fi, you’ll be super secure as long as you don’t transmit passwords in clear text. Get a wireless router which supports 802.1x and deploy where you need a signal.

The LAN

All the other machines that will connect to your networked components. Depending on the size and complexity of your network, you could have other servers, patch panels and switches at other points in your network. Imagine that this part can be very simple (just a few computers) or very complex (many switches, many wireless access points, and other servers which perform various functions).

Summary

I hope this gives you a good introduction to the physical components of the small business network I’ll be walking you through. Please feel free to ask me any questions you might have!

- User authentication required across the network
- Proxy / captive portal
- Varying permissions / workgroups
- Software running in an intranet – not on the cloud (everything from accounting to project management, to timecard entry, to security systems), and accessible via VPN and in some cases web services
- Automated backups, storage and system updates

The first thing I did was hire another network admin to just come in and talk to me for a few hours. He was more of a hardware focused guy, which was fine, because I had no idea on even basic things – like the difference between a switch and a hub (basically that a hub “floods” traffic while a switch routes it intelligently more detail), or how to put an RJ45 on a Cat5e cable. I spent some time checking out Rate My Network Diagram to see some examples of large and small networks, and the physical and virtual components that compose them.

On the software side, I knew I wanted to run Ubuntu Server as our central server, despite the advice of many seasoned network admins on ServerFault who advised “Just use windows server, man, it’s a rock, and everything will just work (as a disclaimer, my experience with Microsoft products is it usually does just work, however klunkily).”

My rational for going with Ubuntu was:

• I already knew Ubuntu fairly well, as I’d been running it for web servers (and doing all the configuration myself) for a couple of years.
• Open source means I can make it do whatever I want
• In the future, clients will be increasingly cross platform (ie I don’t think we’ll be running all PCs in 10 years – several people are using Ipads at work, a few run Linux at home, I use a macbook, and a lot of machines and devices that we could plug into the network run on Unix)
• Ubuntu is crazily well supported.
• Did I say I can make it do whatever I want it to?
• The internet (the biggest network I know of) runs on UNIX

Since choosing a platform and defining some goals, I’ve accomplished quite a bit. So far I:
1. Ordered / assembled of my hardware
2. Got Ubuntu Server running on the machine
3. Configured my managed switch
4. Set up a DHCP server
5. Configured 802.1x authentication via RADIUS and got it working on Mac, Linux & Windows clients
6. Got internet connection sharing working
7. Set up a DNS cache / server

I’ve got a lot left to tackle, but I’m encouraged by the progress I’ve made so far. One of the toughest parts about this project has been the lack of information that brings all of the pieces together in context, yet also drills into detail on the implementation. I’d like to dedicate some time to writing a series of posts which drill into each piece of this project – hardware, networking and software. Hopefully, it will save some time for someone else out there who wants to tackle this kind of project.

The first post will be about hardware – illustrating the physical pieces that go into a computing network and the pieces that they play, and providing some recommendations on what you can get started with. Stay tuned!

Install ClamAV:

sudo apt-get install clamav

And then create a simple bash script that will run clam and send you an email with a summary of the scan:

#! /bin/bash
sudo clamscan -i -r / | sendmail calvinfroedge@gmail.com

The -i flag tells clam you only want to know which files are infected (if any), the -r is to recurse into directories. The pipe then sendmail is to put the output from the clamscan into an email and send it to you.

I’m using SendGrid as my email provider, and it’s easy as hell to integrate with Postfix. Here’s how:

http://docs.sendgrid.com/documentation/get-started/integrate/examples/postfix/

Finally, schedule this to happen each day (or whatever). Put this in your contab (sudo crontab -e):

01 04 * * * /bin/viruscheck

And that’s it! You’ve just fulfilled step 5 of PCI compliance = )