Lukas Pustina - Notes

★ The Real Battle in Local LLM Setup Isn’t the Model

Tue, 19 May 2026 09:00:00 GMT

The question I wanted answered was narrow: with 128 GB of Apple Silicon and one hard rule — fully open, fully local, MLX-native — what is the best agentic-coding stack I can build in May 2026, and what does it cost to keep running?

Short answer: the constraint does most of the design for you, model and backend selection complete in an afternoon, and the real engineering goes into the operations layer. The longer answer is below, with the operational findings packaged as a small open-source tool, 4lm (MIT).

The constraint does most of the work

Open weights, open source, fully local, MLX-native. Each clause removes a category of tooling that dominates the visible market. Open weights rules out the proprietary frontier: Claude, GPT, Gemini, the rest. Open source rules out a handful of MLX-adjacent products with freeware-only or restricted-commercial licences. Fully local rules out hybrid setups that fall back to cloud, which would beg the question. MLX-native rules out containerised runtimes: on macOS, Docker does not expose Metal, and an MLX backend inside a container decodes at roughly half speed. Apple’s own platform punishes you for treating it like Linux.

Once that filter has run, the agent-frontend list collapses to a single entry: OpenCode. Native multi-provider, OpenAI-format first, and the current convergent choice in the open-source agentic-coding community (thoughts.jock.pl carries a contemporary write-up). The backend list collapses to a small set of MLX-native OpenAI-compatible servers, which is where the real selection happens.

Backend: one good answer, briefly revised

In April 2026 the only MLX-native open-source server with per-model tool-call parsing is mlx-openai-server (cubist38), a FastAPI wrapper carrying parsers for qwen3_coder, qwen3_next, glm4_moe, and harmony. On a single afternoon’s evaluation it is the rational pick.

For sustained use it is the wrong pick. Three weeks of running it surfaced failure modes split roughly evenly between MLX itself and the wrapper, and in every case the diagnostic information was sitting in a commit log rather than in any documentation. The replacement, omlx (jundot/omlx), is a vLLM-style MLX runtime with paged KV cache, continuous batching, and a multi-model EnginePool. These three features start to matter the moment a second concurrent client touches the backend. As of May 2026, omlx is the defensible answer.

There is a more general point here. In any domain sitting this close to a moving frontier, the README lies and the commit log does not. Reading commits is part of the job.

Models within the envelope

128 GB excludes most of what made noise in 2026’s open-weights releases. GLM-5 at 744–754B parameters, Kimi K2.6 at 1T total / 32B active, DeepSeek V4-Pro at 1.6T: all of them want ≥256 GB for the aggressive community quantisations, and on 128 GB they fall into mmap-backed disk-offload at below 2 t/s. One agentic iteration takes thirty minutes. There are no Air or Flash variants, and no public roadmap suggesting any are coming. The frontier of open weights has, for now, moved into Mac Studio and M3 Ultra territory.

What fits is the MoE class of 30–80B total parameters with 3–10B active. The architectural reason is simple: decode throughput on Apple Silicon is gated by active-parameter count and memory bandwidth (614 GB/s on the M5 Max), and high sparsity is the only way to use the available bandwidth without exceeding the wired-memory budget.

Among models that fit, Alibaba’s Qwen3 family (Apache 2.0) is the only complete lineup. Coder-Next 80B-A3B (3B active, SWE-Bench Verified 70.6%, 256k context, agentic-trajectory training) handles the build agent; 35B-A3B (3B active, 73.4%, 119 languages, where German vault queries notice the difference) handles plan and chat; Embedding-8B and Reranker-0.6B handle retrieval; VL-8B handles vision. All five share tokeniser and quantisation conventions, run in one omlx EnginePool, and settle at around 65 GB resident. Cross-vendor splits (Qwen for code, GLM-Air for chat, Nomic for embeddings) score comparably per component but multiply the tokeniser, template, and update-cadence surface you have to keep in your head. The operational tax decides it.

Where the local stack stops

A local Qwen3 stack approaches Sonnet 4.5 / Opus 4.6 on a well-defined subset of agentic work, and does not replace them on the complement. It is worth being precise about both halves, because vague claims about local LLMs do most of the damage in this discourse.

The competitive half: single-file edits, multi-turn refactoring inside bounded modules, bash tool use, test generation, small bug fixes with reproducible failure cases, code review, explanation. TTFT under three seconds at a 4k prompt on M5 with Neural Accelerators, which is interactively snappy and the threshold below which you stop reaching for cloud out of impatience.

The other half: multi-file refactors crossing repository boundaries, the harder SWE-Bench Verified cases (local ≈ 73%, Sonnet 4.6 considerably higher), autonomous loops past ~30 tool-use turns where tool-format drift compounds, prompt caching (cache_control has no effect locally), Extended Thinking, multi-hour subagent orchestration. The 95/5 split is not a slogan; it falls out of the architectural limits above.

For me the boundary is in the right place. I do the 95% locally and reach for cloud manually when the other 5% turns up. Automated routers, in my experience, cost tokens and misclassify the precise cases where the route would have paid off.

Where engineering time actually goes

Selection of model and backend completes inside an afternoon. The rest of an honest weekend goes into operations, and three decisions dominate the surface.

Process supervision. Docker is excluded by the constraint, as established. tmux is fragile across reboots and offers no status reporting. The remaining native option is launchd, which is Apple’s answer to systemd and a much older one. Apple’s documentation has not been substantively updated in several macOS releases, and most online tutorials still demonstrate the deprecated load / unload API rather than the current bootstrap / bootout / kickstart; you find this out by reading source.

Four plist defaults bite if you run an MLX backend under launchd. KeepAlive: true restarts on clean exit, which is rarely the intended semantics. The dictionary form { SuccessfulExit: false, Crashed: true } is correct. ThrottleInterval defaults to 10 seconds, and 30 seconds is the right value if you want to avoid a misconfigured daemon saturating a core inside a minute. ExitTimeOut defaults to 20 seconds, which is the window between SIGTERM and SIGKILL; 70+ GB of wired memory does not flush in 20 seconds, and 60 suffices. The fourth default is wired memory itself.

Wired-memory configuration. macOS allocates GPU-accessible memory from a wired pool that defaults to roughly 70% of installed RAM, about 89 GB on a 128 GB system. This is exactly enough for two 8-bit A3B models in steady state, the way a trunk fits exactly two suitcases; it stops being enough the moment the KV cache grows or a third model loads. The correction is iogpu.wired_limit_mb=98304, applied via sysctl and persisted in /etc/sysctl.conf, with a sudoers entry to set it without an interactive password. One line of configuration, and a class of OOM kills you no longer have to diagnose.

Network topology. “Local” is ambiguous as to device. The inference host does not have to be the keyboard. The /v1 seam is reachable from any client on the LAN: opencode on a different laptop, Open WebUI on a different host, plain curl. A common topology is one inference host on mains power (a Mac mini or Studio in a closet) serving several thin clients, including the battery-powered machine that would otherwise spend its day refusing to sleep with 70 GB of wired memory in flight. The backend has no authentication; the network is the perimeter; anything past a trusted LAN goes behind Tailscale.

The tool that came out of it

After three rebuilds of the same operational scaffolding across three profile configurations, the scaffolding became its own project. 4lm (MIT) wraps three MLX-compatible backends (omlx, mlx_lm, ollama) behind one /v1 seam, manages six profile configurations with atomic switching and bounded rollback, enforces the wired-memory limit and newsyslog-based log rotation at install time, and gives you 4lm doctor / 4lm diag when the fans spin up unexpectedly.

Two deployment shapes are supported. The workstation shape (./install.sh && 4lm start && 4lm opencode) gives you Open WebUI on :3000 and opencode in your terminal. The appliance shape (./install.sh --backend-only && 4lm start && 4lm expose lan --confirm) runs the inference host headless and exposes the /v1 seam to the LAN; clients connect at http://<host>:8000. The --confirm flag is deliberate friction, and no environment variable overrides it.

Behind the tool sits a list of ten operational items that no tutorial mentions and every serious stack needs: model pre-pull, HuggingFace cache management, log rotation, dependency pinning, Open WebUI admin-account claim, Tailscale beyond the trusted LAN, WebUI state backup, battery-state interaction with wired memory, per-client MCP configuration. Five are now enforced by install.sh. Four are policy or physics, addressable but not by tooling. One is upstream: per-client MCP duplication will go away the day Open WebUI ships server-side MCP, which is on the 4lm roadmap.

What actually changed in 2026

The thesis fits in one line. Under a hard open-local-MLX constraint, model selection is a short exercise, backend selection has one defensible answer that will shift on a quarterly cadence, and the operational layer is where the engineering time actually goes. What changed in 2026 is that the operational answers are now identifiable in advance and installable in one command.

Set the wired-memory limit, write a proper plist, point the couch laptop at the closet Mac. Then walk away. The day it acts up, and on a six-month cadence it will, the README will be wrong and the merge log won’t.

Why GC sometimes beats Rust

Sat, 07 Nov 2020 00:00:00 GMT

Today I read an article that resonated very nicely with a feeling I have about Rust from time to time. The article is This Week in Programming: When to Choose F# Over Rust and at the end there this quote by Paul Biggar:

By having a GC, we don’t have to do any of the stuff that causes all these problems in Rust. Maybe that costs performance, but I need the ability to quickly write code a lot more than I need the extra performance.

I think, that’s true. After more than 5 years of Rust, I still struggle to just write a fire and forget program in a quick’n’dirty way. There’s no quick’n’dirty in Rust. It doesn’t want it. But sometimes I do.

Can a function with no body be useful, yes!

Tue, 05 Nov 2019 00:00:00 GMT

Jaseem Abid describes his favorite Rust function std::mem::drop

My favorite rust function is std::mem::drop which is used to free or deallocate a value, similar to free() in C.

pub fn drop<T>(_x: T) { }

The reason this function actually has a purpose is because of Rust’s ownership model:

Calling a function moves the ownership of the arguments and if the called function decides to do nothing with it, the arguments will be dropped - which is exactly what we wanted!

Jaseem closes his post with a quote from Alan J. Perlis:

A language that doesn’t affect the way you think about programming is not worth knowing.

I very much like this idea.

Rust: Elevator Pitch for impl Trait

Sat, 18 May 2019 00:00:00 GMT

According to the announcement of Rust 1.26 in May, 2018, impl Trait the elevator pitch is this:

fn foo() -> impl Trait {
   // ...
}
This type signature says “foo is a function that takes no arguments but returns a type that implements the Trait trait.” That is, we’re not going to tell you what the return type of foo actually is, only that it implements a particular trait. You may wonder how this differs from a trait object:

Why is this useful? One good use is closures. Remember that closures in Rust all have a unique, un-writable type, yet implement the Fn trait. This means that if your function returns a closure, you can do this:
// before
fn foo() -> Box<Fn(i32) -> i32> {
    Box::new(|x| x + 1)
}

// after
fn foo() -> impl Fn(i32) -> i32 {
    |x| x + 1
}
No boxing, no dynamic dispatch. A related scenario happens when returning iterators.

But for all the developers using dynamic dispatch by default (like in Java, Python etc.), keep in mind this does evaluate at compile time and not dynamically at runtime. Therefore:

It’s important to note that sometimes trait objects are still what you need. You can only use impl Trait if your function returns a single type; if you want to return multiple, you need dynamic dispatch. For example:
fn foo(x: i32) -> Box<Iterator<Item = i32>> {
    let iter = vec![1, 2, 3]
        .into_iter()
        .map(|x| x + 1);

    if x % 2 == 0 {
        Box::new(iter.filter(|x| x % 2 == 0))
    } else {
        Box::new(iter)
    }
}

What is DevOps

Sat, 18 May 2019 00:00:00 GMT

Chris Short defines DevOps as

DevOps is the professional practice of frequent, continued, and iterative improvements through measurable changes, the goal of which is to become a high-velocity organization thus improving business outcomes.

DevOps comprises Professional Practice; Frequent, Continued, and Iterative Improvement; High-Velocity Organization; Measurable Changes; Business Outcomes.

And what DevOps is not as stated by Lemi Orhan Ergin in his famous tweet:

Let’s clarify:

Jira is not Agile

Open Source is not Free

Using cloud is not DevOps

Rituals is not Scrum

Developed is not Done

How colors influence ls's speed and doors open

Wed, 08 May 2019 00:00:00 GMT

Kilian from Standford’s Sherlock team presents a very interesting analysis of why ls might feel slow. He started his investigation after a user reports:

It all started from a support question, from a user reporting a usability problem with ls taking several minutes to list the contents of a 15,000+ entries directory …

While I have experienced slow file system interactions when working with a large amount of files in one directory before and even analysed it to cache evictions in the XFS’ kernel memory, I’ve have never thought about Kilian’s findings regarding ls’s colorful output’:

But those pretty colors come at a price: for each and every file it displays, ls needs to get information about a file’s type, its permissions, flags, extended attributes and the like, to choose the appropriate color to display.

For every file in the directory, ls makes calls to lstat(), getxattr(), and capget(). This makes 15.000+ * 3 syscalls which, well, takes quite some time.

The second part of the article show’s how you can affect the runtime by adapting the coloring options of ls by changing the environment variable LS_COLORS. This variable is usually set by the executable dir_colors (1) and the configuration file dir_colors (5) — see respective man pages for details.

In the end, the article give a peek on a UNIX file type called “Door” file which is amazing and just because of this, the article is worth a read. I’m using Unix for almost 25 years professionally, I’ve never heard of Door files … there’s always something old to learn.

Vimways - A Vim-themed advent calendar

Sun, 09 Dec 2018 00:00:00 GMT

I just found this via Changelog #233. It’s really nice.

Looking at TDD: An Academic Survey

Sat, 29 Sep 2018 00:00:00 GMT

Ted M. Young surveys academic papers regarding the pros and cons of Test Driven Development (TDD). Most papers come to the conclusion that TDD benefits or at least does not harm resulting code.

For future references, I like to highlight these two points:

First, Ted cites an article from the IEEE Software journal: “Does Test-Driven Development Really Improve Software Design Quality?”

Our results indicate that test-first programmers are more likely to write software in more and smaller units that are less complex and more highly tested.

Second, the cited survey paper “Towards an operationalization of test-driven development skills: An industrial empirical study” comes to this conclusion:

(i) refactoring is performed as often as TDD requires, and it is considered less important

[…]

(iv) participants first imagine the source code to be implemented and then write tests

[…]

we observed that developers tended to write more code than necessary to pass the unit test

To which Ted adds:

That last highlight is why TDD teachers harp on taking such small steps, because it’s so damned easy to write more code than is needed, thinking I know I’ll need to check for this condition later, so let me just write that code now, which not only “leaves part of the source code uncovered by tests” (from the conclusion above), because that’d be easily remedied by just writing some more tests, it’s that it may be the wrong design, as in, the code might be in the wrong place, it might not be the right code, etc., but you won’t know because you came at it from a code-first point of view.

★ Where Vim came from or why I prefer Vim

Wed, 15 Aug 2018 00:00:00 GMT

I love this kind of stories: Putting today’s tools and techniques into historical context. Sinclair Target gives a brief history of Vim and concludes:

In 2006, Vim was voted the most popular editor among Linux Journal readers. Today, according to Stack Overflow’s 2018 Developer Survey, Vim is the most popular text-mode (i.e. terminal emulator) editor, used by 25.8% of all software developers (and 40% of Sysadmin/DevOps people). For a while, during the late 1980s and throughout the 1990s, programmers waged the “Editor Wars,” which pitted Emacs users against vi (and eventually Vim) users. While Emacs certainly still has a following, some people think that the Editor Wars are over and that Vim won.16 The 2018 Stack Overflow Developer Survey suggests that this is true; only 4.1% of respondents used Emacs.

In my opinion an editor is one of the most important applications; maybe even the most important. It’s one of the primary ways you interact with computers. The better you know how to effectively operate “your” editor, the more efficient you interact with computers.

I’m using Vim for almost forever. What I like the most about Vim is that its main focus is on how to manipulate text efficiently. No matter if in a terminal or in GUI, Vim can be completely operated using the keyboard. Moving the cursor, jumping to a location where you want to edit, as well as selecting and mangling text is at the heart of Vim. On top of the that, the whole editor is programmable in a way that text manipulation can be automated quickly with a minimum of friction. This way of engaging with text, may it be source code or just regular text, are superior to any other editor I have used.

I do understand that with every new generation of computer engineers, there is this drive to re-invent the wheel. Right now Atom and Visual Studio Code are the “hot shit”. They make it seem like it were almost impossible to do, for example, JavaScript development with other editors. And while I can see value in these editors, they always fail regarding the basic tasks an editor has to fulfill: Mangling text! That’s why all these editors sooner or later grow various Vim keyboard shortcuts plugins, because people miss Vim’s way to edit text. But these plugins always fall short implanting Vim’s way to do things into editors following completely other paradigms.

In the end, every editor and of course every IDE has to be judged by the means it offers to manipulate text. And there’s yet to come a serious contender to Vim^[1].

I know this is too harsh. I used to use Emacs for some years and it’s similar capable, but I ended up with Vim eventually and that’s a topic for another note. ↩︎

Pointers Are Complicated, or: What’s in a Byte?

Mon, 30 Jul 2018 00:00:00 GMT

Ralf Jung explains what a “pointer” in Rust or C really is and why pointers pointing to the same address may still not be equivalent.

int test() {
    auto x = new int[8];
    auto y = new int[8];
    y[0] = 42;
    auto x_ptr = x+8; // one past the end
    if (x_ptr == &y[0])
      *x_ptr = 23;
    return y[0];
}
Now, imagine that x and y have been allocated right next to each other, with y having the higher address. Then x_ptr actually points right at the beginning of y! The conditional is true and the write happens. Still, there is no UB [*undefined behavior“] due to out-of-bounds pointer arithmetic. The key point here is that just because x_ptr and &y[0] point to the same address, that does not make them the same pointer, i.e., they cannot be used interchangeably: &y[0] points to the first element of y; x_ptr points past the end of x. If we replace *x_ptr = 23 by *&y[0] = 0, we change the meaning of the program, even though the two pointers have been tested for equality.

We have seen that in languages like C++ and Rust (unlike on real hardware), pointers can be different even when they point to the same address, and that a byte is more than just a number in 0..256. This is also why calling C “portable assembly” may have been appropriate in 1978, but is a dangerously misleading statement nowadays.

Goodbye Microservices: From 100s of problem children to 1 superstar

Tue, 17 Jul 2018 00:00:00 GMT

Alexandra Noonan describes how Segment moved from monolith to microservices and back again to a monolith.

Segment offers an API that collects data from different devices, mobile apps, and websites and distributes them to a plethora of integration to process your data. It’s like an API Router with a standard interface for various services.

The touted benefits [of microservices] are improved modularity, reduced testing burden, better functional composition, environmental isolation, and development team autonomy. The opposite is a Monolithic architecture, where a large amount of functionality lives in a single service which is tested, deployed, and scaled as a single unit.

In early 2017 we reached a tipping point with a core piece of Segment’s product. It seemed as if we were falling from the microservices tree, hitting every branch on the way down. Instead of enabling us to move faster, the small team found themselves mired in exploding complexity. Essential benefits of this architecture became burdens. As our velocity plummeted, our defect rate exploded.

Eventually, the team found themselves unable to make headway, with 3 full-time engineers spending most of their time just keeping the system alive. Something had to change. This post is the story of how we took a step back and embraced an approach that aligned well with our product requirements and needs of the team.

They decided to move back to a monolith for the particular product. An important cornerstone of this move was to build fast, reliable tests:

We also wanted a test suite that allowed us to quickly and easily run all our destination tests. Running all the tests was one of the main blockers when making updates to the shared libraries we discussed earlier.

Fortunately, the destination tests all had a similar structure. They had basic unit tests to verify our custom transform logic was correct and would execute HTTP requests to the partner’s endpoint to verify that events showed up in the destination as expected.

Recall that the original motivation for separating each destination codebase into its own repo was to isolate test failures. However, it turned out this was a false advantage. Tests that made HTTP requests were still failing with some frequency. With destinations separated into their own repos, there was little motivation to clean up failing tests. This poor hygiene led to a constant source of frustrating technical debt. Often a small change that should have only taken an hour or two would end up requiring a couple of days to a week to complete.

But running tests against real endpoints took too much time:

Some destinations took up to 5 minutes to run their tests. With over 140 destinations, our test suite could take up to an hour to run.

To solve for both of these, we created Traffic Recorder. Traffic Recorder is built on top of yakbak, and is responsible for recording and saving destinations’ test traffic. Whenever a test runs for the first time, any requests and their corresponding responses are recorded to a file. On subsequent test runs, the request and response in the file is played back instead requesting the destination’s endpoint. These files are checked into the repo so that the tests are consistent across every change.

Segment’s velocity accelerated again:

The proof was in the improved velocity. In 2016, when our microservice architecture was still in place, we made 32 improvements to our shared libraries. Just this year we’ve made 46 improvements. We’ve made more improvements to our libraries in the past 6 months than in all of 2016.

One of their conclusions is that a fast and reliable test suits is required. But once you have that the software engineering benefits of microservices do not weight that much anymore compared to a monolith.

We needed a rock solid testing suite to put everything into one repo. Without this, we would have been in the same situation as when we originally decided to break them apart. Constant failing tests hurt our productivity in the past, and we didn’t want that happening again.

Rust stabilized try_fold and try_for_each

Fri, 06 Jul 2018 00:00:00 GMT

In Rust 1.27 the iterator combinators try_fold and try_for_each have been stabilized. Both allow to iteratively apply a function to elements of an iterator until it’s either exhausted or the first error is encountered through Option::None or Result::Err. For example this can be used for short-circuiting^[1]:

fn main() {
  let stuff = vec![1, 2, 3, 4];
  let mut iter = stuff.into_iter();

  let res = iter
    .try_for_each(|x| not_3(x));

  println!("Reult: {:?}", res);
  println!("Iterator is not exhausted and still has {} elements", iter.len());
}

// try_for_each expectd Option<()> or Result<(),_> because of Try<Ok = ()>
fn not_3(x: isize) -> Option<()> {
  if x == 3 { return None };
  Some(())
}

See this playpen ↩︎

From &str to Cow

Wed, 04 Jul 2018 00:00:00 GMT

Yesterday’s note on The Secret Life of Cows shows how to use Cow as function return type when the function may return an owned type or a reference, e.g., String or a &str. Jow Wilm shows how to apply Cow in a data structure with an ergonomic constructor:

struct Token<'a> {
    raw: Cow<'a, str>
}

impl<'a> Token<'a> {
    pub fn new<S>(raw: S) -> Token<'a> where S: Into<Cow<'a, str>> {
        Token { raw: raw.into() }
    }
}

// Create the tokens.
let token = Token::new("abc123");
let token = Token::new(String::new("abc123"));

The Problem You Solve Is More Important Than The Code You Write

Tue, 03 Jul 2018 00:00:00 GMT

Fagner Brack

Programmers seem to have forgotten the real purpose of software, that is to solve a real-world problem.

50 years ago, in 1968, the Working Conference on Software Engineering was held, sponsored by the NATO Science Committee. At that time, people started to notice software was becoming a fundamental part of society. However, it was also becoming too hard to understand. After that conference, programming started to become a whole industry. It started to move away from the control of business people.

Regardless of the path programming has taken since then, there’s still a problem with the separation between business and software development — or “engineering” as the conference called for the first time. If developers become too narrowly focused on development, they can miss the purpose behind the software they write. They may not see hidden solutions that don’t require any code.

With understanding of what a customer needs you may realize that some code is just not necessary to write.

However, just like Technical Debt, nothing should be used as an excuse to write crap code in the rest.

Not every code is worth writing

YAGNI

The Secret Life of Cows

Tue, 03 Jul 2018 00:00:00 GMT

Pascal Hertleif gives a comprehensive introduction to the Cow type and discusses when and how to use it:

One very cool use-case for Cows is when dealing with functions that either return static strings (i.e., strings you literally write in your source code) or dynamic strings that get put together at run time. The Programming Rust book by Jim Blandy and Jason Orendorff contains an example like this:

use std::borrow::Cow;

fn describe(error: &Error) -> Cow<'static, str> {
    match *error {
        Error::NotFound => "Error: Not found".into(),
        Error::Custom(e) => format!("Error: {}", e).into(),
    }
}

Why is this a very cool example? Reddit user 0x7CFE put it like this:

The most important thing is that since Cow<'static, str> derefs to &str it may act as a drop-in replacement everywhere, where &str is expected. So, if last error variant was added to an already existing code base, all would just work without any major refactoring.

[…]

Rust provides a solution that is zero cost for cases where extra details are not needed. It’s a brilliant example of “pay only for what you use” principle in action.

So basically when you need to return an owned or a referenced string, but it’s not clear which exactly it will be, Cow gives you a way to express this. And of course this holds for any type not just strings.

And together with AsRef you can write functions that take both owned types and references and return a Cow. Dereferencing of the input and allocation for the output is then handles accordingly^[1]:

use std::borrow::Cow;

fn pay_per_use<'a, T: AsRef<str>>(a_string: T) -> Cow<'a, str> {
    a_string.as_ref().to_lowercase().into()
}

fn main() {
    let a_str = "Lukas was here";
    let a_string = "Lukas was here".to_owned();

    println!("{}", pay_per_use(a_str));
    println!("{}", pay_per_use(&a_string));
    println!("{}", pay_per_use(a_string));
}

See this playground. ↩︎

★ Revisiting Rust’s Function Pointers

Sun, 17 Jun 2018 00:00:00 GMT

I once needed a function that takes an optional function pointer. This is quite easy to express in Rust:

fn maybe_closure<T: FnMut(String) -> ()>(closure: Option<T>) -> () {
  ...
}

maybe_closure(Some(...));

But I ran into a problem calling maybe_closure with None

maybe_closure(None);

because the compiler could not infer the concrete type of None in this context

11  |         maybe_closure(None);
    |                  ^^^^^^^^^^^^^^^^^^ cannot infer type for `T`
    |
    = note: type annotations or generic parameter binding required

even when I specified the type using the turbo fish syntax

    |
11  |         maybe_closure(None::<FnMut(String) -> ()>);
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::marker::Sized` is not implemented for `std::ops::FnMut(std::string::String)`
    |
    = note: `std::ops::FnMut(std::string::String)` does not have a constant size known at compile-time
    = note: required by `std::prelude::v1::None`

So I asked the friendly Rust users and xfix provided the correct answer

maybe_closure(None::<fn(_)>);

As history repeats itself, I was confronted with a similar question recently and to my surprise googled my exact same question from a year ago. Now it’s time to understand the details.

`Option` is a Generic Type

First, why does the compiler need to infer type for T for None?

Option is an enum that holds a generic data type in one of its variants, i.e., Some(T). Here’s the definition of Option:

pub enum Option<T> {
    None,
    Some(T),
}

So Option<T> is a type constructor for concrete types with type parameter T. This means that Option<A> and Option<B> with A != B are two different types. For example Some(10) and Some("10") are of different types as well as None::<i32> and None::<&str>.

Since None does not explicitly state of which concrete type it is, the compiler cannot infer the concrete type in a situation as above when we just pass None to the maybe_closure function.

`Fn`, `FnMut`, and `FnOnce` are Traits

So why didn’t maybe_closure(None::<FnMut(String) -> ()>); solve the problem?

Since Fn, FnMut, and FnOnce are traits they do not have a constant size. Only concrete types have a constant size and thus, only concrete types that implement a trait may be passed to a function. We could use Box<T> which is Rust’s smart pointer for data on the heap to get a constant size parameter for our function, but that would make using the our maybe_closure even more cumbersome.

Primitive Type `fn`

The solution xfix pointed out uses the primitive type fn which is a function pointer. Since this is a primitive type, it has a concrete size. But why does fn(_) type check for maybe_closure? The explanation can be found in the Rust documentation for fn:

In addition, function pointers of any signature, ABI, or safety are Copy, and all safe function pointers implement Fn, FnMut, and FnOnce. This works because these traits are specially known to the compiler.

So fn implements FnMut and is of constant size.

Summary

Passing functions and closures as parameters to functions requires constant sizes. If the parameter should be an optional None, the compiler needs explicit type information to type check the function call.

This simple Rust program illustrates this in detail. It’s also available as gist on Github and on Playground.

// Takes a function pointer from i32 to i32
fn takes_a_fp(f: fn(i32) -> i32, value: i32) -> i32 {
    f(value)
}

// Takes a closure with the trait bound Fn(i32) -> i32
fn takes_a_closure<T: Fn(i32) -> i32>(f: T, value: i32) -> i32 {
    f(value)
}

// Takes a closure with the trait bound Fn(i32) -> i32 using 1.26 impl syntax
fn takes_a_closure_impl(f: impl Fn(i32) -> i32, value: i32) -> i32 {
    f(value)
}

// Takes an optional function pointer from i32 to i32
fn takes_an_opt_fp(f: Option<fn(i32) -> i32>, value: i32) -> Option<i32> {
    if let Some(f) = f {
        Some(f(value))
    } else {
        None
    }
}

// Takes an optional closure with the trait bound Fn(i32) -> i32
fn takes_an_opt_closure<T: Fn(i32) -> i32>(f: Option<T>, value: i32) -> Option<i32> {
    if let Some(f) = f {
        Some(f(value))
    } else {
        None
    }
}

// Takes an optional closure with the trait bound Fn(i32) -> i32 using 1.26 impl syntax
fn takes_an_opt_closure_impl(f: Option<impl Fn(i32) -> i32>, value: i32) -> Option<i32> {
    if let Some(f) = f {
        Some(f(value))
    } else {
        None
    }
}

// Function from i32 -> i32
fn id(x: i32) -> i32 {
    x
}

fn main() {
    // Closure from i32 -> i32
    let closure = |x: i32| x;

    println!("takes_a_fp(closure, 42): {}", takes_a_fp(closure, 42));
    println!("takes_a_fp(fn, 42): {}", takes_a_fp(id, 42));
    println!();

    println!("takes_a_closure(closure, 42): {}", takes_a_closure(closure, 42));
    println!("takes_a_closure(fn, 42): {}", takes_a_closure(id, 42));
    println!();

    println!("takes_a_closure_impl(closure, 42): {}", takes_a_closure_impl(closure, 42));
    println!("takes_a_closure_impl(fn, 42): {}", takes_a_closure_impl(id, 42));
    println!();

    println!("takes_an_opt_fp(closure, 42): {:?}", takes_an_opt_fp(Some(closure), 42));
    println!("takes_an_opt_fp(fn, 42): {:?}", takes_an_opt_fp(Some(id), 42));
    // The type of `f` is unambiguous, therefore Rust can infer the correct type of Option<f> for None
    println!("takes_an_opt_fp(None, 42): {:?}", takes_an_opt_fp(None, 42));
    println!();

    println!("takes_an_opt_closure(closure, 42): {:?}", takes_an_opt_closure(Some(closure), 42));
    println!("takes_an_opt_closure(fn, 42): {:?}", takes_an_opt_closure(Some(id), 42));
    println!("takes_an_opt_closure(None, 42): {:?}", takes_an_opt_closure(None::<fn(_) -> i32>, 42));
    println!();

    println!("takes_an_opt_closure_impl(closure, 42): {:?}", takes_an_opt_closure_impl(Some(closure), 42));
    println!("takes_an_opt_closure_impl(fn, 42): {:?}", takes_an_opt_closure_impl(Some(id), 42));
    // The type of `f` is unambiguous, therefore Rust can infer the correct type of Option<f> for None
    println!("takes_an_opt_closure_impl(None, 42): {:?}", takes_an_opt_closure_impl(None::<fn(_) -> i32>, 42));
}

You’re Doing Scrum Wrong, and Here’s How to Fix It

Tue, 12 Jun 2018 00:00:00 GMT

Eric Weiss explains the fallacies that might occur when you forget the founding principles of the Agile Manifesto and become too strict about your process, for example, Scrum. When you just rigidly follow the rules of Scrum, you divert from Agile Software Development to what Eric calls the “Assembly Line Scrum”:

The Assembly Line, or Mini-Waterfall model, focuses all of its energy on the estimation, measurement, and control of velocity. In this assembly line, the story point is the unit of production, and all systems and processes are designed to maximize productivity. In this model, a significant amount of overhead is invested in estimating tasks, logging work, developing burn-down charts and sprint reports, and providing status in the daily standups. To try new things and experiment with the process would introduce risk into the production line. To maximize feature output, there is little room to invest in automation, paying down technical debt, learning new technologies, improving documentation, or experimenting with the development process. If this sounds like you, and you aren’t meaningfully investing in continuous improvement, you’re doing Scrum all wrong.

The continues to explain the ceremonies of Scrum that make building blocks of the process:

The purpose of the sprint planning ceremony is to ensure that all high priority tasks are clearly defined and actionable, that clear success criteria are understood by the entire team, and to commit to a scope of work that will not be broken or altered during the course of the sprint.

For me, the daily standup is the most important ceremony of any Agile Development Process, because that’s where information flow openly between team members:

In Assembly Line Scrum, the daily standup is used to gather and up-to-the-minute status update so that the Scrum Master and Product Owner can update their status reports. This does nothing to improve the ability of the team to execute mid-cycle. In successful Scrum teams, the standup is reserved for communicating roadblocks.

If an engineer is missing a critical dependency or piece of information, is unclear about the objective or success criteria of a story, or is otherwise blocked, it is the team’s duty to help clear those roadblocks. If the engineer has no roadblocks and has a clear direction for the day, he or she can simply cede their time. The status can be easily observed in the sprint board itself. This is how you keep a stand up to 15 minutes and physically standing, by focusing on helping the engineers succeed, rather than trying to get up-to-the-minute status.

And finally, the retrospective that enabled the feedback loop into your team:

The retrospective is the single most important ceremony in the entire development process. If you are not performing a retrospective in earnest at the end of every sprint, where you identify what is working and not working in your process, and brainstorm and commit to trying new things, you are completely disregarding the principles of agile software development.

Adopt Microservices?

Wed, 23 May 2018 00:00:00 GMT

Rebecca explains why microservices haven’t yet made it into the Adopt ring of ThoughtWorks’ Technology Radar even though, ThoughtWorks recommends to and uses microservices at clients:

Not all organizations are microservices-ready

because:

As Martin Fowler points out here in one of his posts on microservices, there’s a minimum level of maturity needed in things like continuous delivery and infrastructure automation practices before microservices should be considered. This level of maturity is still a stretch for many organizations. Microservices place an increased burden on operations, given there are more things to monitor and alert, as well as more things to deploy. Comprehensive automation and continuous delivery practices are essential in this context.

And further:

Similarly, a microservices architecture has error modes that simply aren’t possible in a monolithic application. Microservices systems are inherently distributed, and business processes are most often completed through the interaction of multiple microservices. In a monolith, these business processes execute most often within the same process boundary, allowing for traditional transactions and ensuring all or nothing execution. While we have solutions for all of these problems, the microservice approach introduces these problems and requires them to be dealt with. Thus, there’s a trade-off (a common one) between the increased flexibility of the microservices approach and the simplicity of the monolithic approach, particularly if it is a well-structured monolith. Applications that won’t benefit as much from the flexibility are poor candidates for a microservices architecture.

Besides the challenges Microservice architectures put on ops, there is also a very important software engineering aspect to consider:

A crucial design decision for a microservices architecture is the placement of the boundaries between services. While bounded contexts certainly provide strong guidance for where the appropriate boundaries are, choices still exist and the wrong choice complicates the system. It might not actually be clear for a new domain where the proper boundaries are, so there’s some justification for not starting with a microservices architecture until the domain and the proper contexts are more clear.

Justin Etheredge made exactly this point.

Developers Should Abandon Agile

Wed, 23 May 2018 00:00:00 GMT

Ron Jeffries is one of the original authors of the Agile Manifesto and he says that the principals of the Agile movement have become clouded while processes became the center of attention. Following the process became so much more important that we forgot how to implement the fundamental principles. And while business is happy about being “Agile”, the developers suffer:

When “Agile” ideas are applied poorly, they often lead to more interference with developers, less time to do the work, higher pressure, and demands to “go faster”. This is bad for the developers, and, ultimately, bad for the enterprise as well, because doing “Agile” poorly will result, more often than not, in far more defects and much slower progress than could be attained. Often, good developers leave such organizations, resulting in a less effective enterprise than prior to installing “Agile”.

And that

[…] breaks my heart to see the ideas we wrote about in the Agile Manifesto used to make developers’ lives worse, instead of better. It also saddens me that the enterprise isn’t getting what it could out of the deal, but my main concern is for the people doing the work.

Over a period of years, I’ve heard from many developers who say that “Agile” sucks. (Usually they say that “Scrum” sucks, because most people in organizations trying to do “Agile” are in organizations trying to do Scrum.) I’ve tried to help those people understand that their organization is doing “Agile” wrong: they’re not doing what the Manifesto authors recommended, what Scrum recommends, what the many Agile Software Development experts recommend. My hope was that people within the sound of my voice would help themselves, and their organizations, move closer to the real ideas behind Manifesto Agile and away from the many forms of Faux Agile or Dark Agile that we see around us.

He suggests that “Developers should abandon “Agile”” and “Detach from named methods” and instead follow the foundational principles:

More generally, developers’ work should adhere to the foundational principles that support Agile Software Development, as we had in mind when we wrote the Manifesto. Today, I’d summarize the ideas this way:

Produce running, tested, working, integrated software every two weeks, every week. Build your skills until you can create a new fully operational version every day, twice a day, multiple times a day.

Keep the design of that software clean. As it grows, the design will tend to become complex and crufty. Resist and reverse this tendency consciously, refactoring in tiny continuous steps, all the time, so that your rate of progress is as steady and consistent as possible.

Use the current increment of software as the foundation for all your conversations with your product leadership and management. Speak in terms of what’s ready to go, and in terms of what they’d like you to do next.

And while implementing this is going to be hard:

It won’t be perfect, and for a while at least, it probably won’t be fun. It’s just the best chance I know to survive down in that code mine. Having a completed running product slice is the best way I know to possibly turn the situation around. In a bad situation, all we can do is our best, and try to help things to get better.

I totally agree with his conclusion:

However, the values and principles of the Manifesto for Agile Software Development still offer the best way I know to build software, and based on my long and varied experience, I’d follow those values and principles no matter what method the larger organization used.

And I add the principles from the Manifesto for reference:

Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.

Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage.

Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.

Business people and developers must work together daily throughout the project.

Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.

The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.

Working software is the primary measure of progress.

Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.

Continuous attention to technical excellence and good design enhances agility.

Simplicity — the art of maximizing the amount of work not done — is essential.

The best architectures, requirements, and designs emerge from self-organizing teams.

At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.

And here are the Manifesto’s core values:

Individuals and interactions over processes and tools

Working software over comprehensive documentation

Customer collaboration over contract negotiation

Responding to change over following a plan

The Rise of Rust in DevOps

Tue, 22 May 2018 00:00:00 GMT

Florian Leibert: What types of projects do you think Rust is best suited for?

Steve Klabnik: […] Another great use for Rust is when you’re coding something that has to be 100% accurate, which sounds like a strange concept because no one wants their code to be wrong, but very few programs must be 100% correct. Engineering is all about tradeoffs, and sometimes something that works 80% of the time is good enough. Rust contains a set of guarantees that tend to take a little bit longer to develop initially, but they do a really good job of forcing you to write correct code.

Obviously, no one would ever claim that every Rust program is perfect, but our users say that they tend to spend significantly less time debugging after the fact. One of our production users has said that they enjoy Rust because it’s boring operationally. Once they put it into production, they don’t have to worry about it ever again. In general, you just write it and then it does what it says and you forget about it. It’s both boring and exciting.

That’s exactly one reason why I like Rust so much. Once your project compiles and runs, you can forget about it. I’ve developed rs-collector in Rust and it’s running on 50+ machines for almost 2 years now. So far we haven’t had a single bug or crash! And that’s only because of Rust’s safety guarantees. rs-collector makes heavy use of threads and we haven’t had a single concurrency related bug! None!

Docker or Glueing together Stuff you don’t Understand

Thu, 17 May 2018 00:00:00 GMT

I have very ambiguous feelings about Docker. I used to love it. Then I used to hate it. Nowadays I mostly ignore it. The reason why? Well one of them has been captured by xkcd:

You’re Not Actually Building Microservices

Tue, 15 May 2018 00:00:00 GMT

I have never build a system comprised of distributed microservices. I have never required a microservice architecture. Our application at CenterDevice is quite large and complex. And I still haven’t seen the need to break our “monolith” into several microservices. So I have to admit that I never really grasped the enthusiasm about microservices even though I spoke to different people actually building microservice based applications. Just last weekend a close friend and excellent software engineer told me the story about a client that only uses microservice architectures for its application. Each nightly build takes 8 hours to complete because every microservice code base has to be compiled. And the deployment is similar complex.

Don’t get me wrong, any buzzword transcend its original meaning and becomes easily an empty phrase that you can make fun of. That’s not my intention. I just didn’t understand the idea of microservices until I found this article by Justin Etheredge in which he makes a very important observation. First, he cites the definition of a monolith from Wikipedia:

A software system is called “monolithic” if it has a monolithic architecture, in which functionally distinguishable aspects (for example data input and output, data processing, error handling, and the user interface) are all interwoven, rather than containing architecturally separate components.

And concludes — his emphasis:

The basic idea is that instead of being broken out into separate architectural components, things are instead intertwined. […] there is nothing in this definition about the fact that these pieces are, or are not, physically distributed from each other. We like to think of monoliths as a large single codebase, running on a single system, but that really isn’t the case. The core tenet of a monolith is that the system functionality is intertwined.

So, if we take the distributed deployment away, we realize that the architecture of our application actually answers the question “monolith vs. microservice”.

So, if we follow that course of logic, then what would a distributed monolith be? Well, it would be a set of physically distributed services that are intertwined. Sound familiar?

You see, a distributed monolith is the worst of all worlds. You’ve taken the relative simplicity of a single monolithic codebase, and you’ve traded it in for a deeply intertwined distributed system. So, are you building microservices? Take a look at a few of these symptoms, and decide for yourself:

A change to one microservice often requires changes to other microservices

Deploying one microservice requires other microservices to be deployed at the same time

Your microservices are overly chatty

The same developers work across a large number of microservices

Many of your microservices share a datastore

Your microservices share a lot of the same code or models

And that really rings a bell.

So when do you actually need microservices, when does they make sense?

If you start off with a monolith, your goal should be to keep it from growing into a monstrosity. The key to doing this is to simply listen to your application! I know, this is easier said than done, but as your monolith grows, keep asking yourself a few questions:

Is there anything that is scaling at a different rate than the rest of the system?

Is there anything that feels “tacked-on” to the outside of the system?

Is there anything changing much faster than the rest of the system?

Is there a part of the system that requires more frequent deploys than the rest of the system?

Is there a part of the system that a single person, or small team, operates independently inside of?

Is there a subset of tables in your datastore that isn’t connected to the rest of the system?

And when is the time to move to microservices?

You hear about companies like Netflix or Uber that have hundreds of microservices in their ecosystems. These companies are at the extreme end of the scale. They have thousands of developers and are often deploying thousands of times per day. They need tons of fine-grained services in order to make any of this sane and manageable.

Because:

But what they might think of as a fine-grained service is probably a medium sized application to a much smaller company. […] when you get down to the other extreme end of the scale, where you have less than five developers working on an entire system, you’ll find that there are huge advantages to sticking with a monolith and potentially pulling out a service or two — if it really makes sense.

So in the end, as the take away, Justin quotes Martin Fowler:

Don’t even consider microservices unless you have a system that’s too complex to manage as a monolith.

So in the end, our application at CenterDevice might actually be a microservice application that consists of a handful of monoliths — depending on your point of view.

Uncle Bob about FP vs. OO

Sun, 13 May 2018 00:00:00 GMT

Robert C. Martin a.k.a Uncle Bob argues that FP and OO work nicely together and that both concepts are even desirable to play together. For the sake of the argument he reduces object oriented and functional programming to a single core princple each:

So our reductive definition of OO is:

The technique of using dynamic polymorphism to call functions without the source code of the caller depending upon the source code of the callee.

and

So, the reductive definition of functional programming is:

Referential Transparency – no reassignment of values.

He concludes:

It seems clear that the two reductive definitions I have chosen are completely orthogonal. Polymorphism and Referential Transparency have nothing, whatever, to do with each other. There is no intersection between them.

But orthogonality does not imply mutual exclusion (just ask James Clerk Maxwell). It is perfectly possible to build a system that employs both dynamic polymorphism and referential transparency. Not only is it possible, it is desirable!

Why is it desirable? For precisely the same reasons that the two aspects are desirable alone! We desire systems built with dynamic polymorphism because they are strongly decoupled. Dependencies can be inverted across architectural boundaries. They are testable using Mocks and Fakes and other kinds of Test Doubles. Modules can be modified without forcing changes to other modules. This makes such systems much easier to change and improve.

We also desire systems that are built with referential transparency because they are predictable. The inability to change internal state makes systems much easier to understand, to change, and to improve. It drastically reduces the chances of race conditions and other concurrent update problems.

I very much like this and I think languages like for example Scala and Rust have internalized this quite well.

CPU Utilization is Wrong

Mon, 30 Apr 2018 00:00:00 GMT

Brendan Gregg renown performance expert currently with Netflix presented at UpSCALE what he thinks is wrong about monitoring CPU utilization. And why it’s getting worse while CPUs get faster.

Brendan presents that the general understanding of CPU utilization is the ratio between the CPU working and being idle as measured by the kernel. When in fact it’s dramatically different in that the kernel can’t distinguish between the CPU executing instructions and waiting (“being stalled”) for external resources.

At Netflix he observed in general that a 90% utilized CPU is actually busy waiting 70% for external resources and only 20% executing instructions. He illustrated his findings with an example regarding MySQL using various CPU low-level tools and makes a devastating realization why recent Linux kernel changes had such a negative impact on overall performance.

Brendan’s talk is just 5 minutes long, but full of insight. There’s also his blog post KPTI/KAISER Meltdown Initial Performance Regressions going in to more details.

There is no Production or Test Code - just Product Code

Mon, 23 Apr 2018 00:00:00 GMT

Developers starting to delve into Test Driven Development or automatic testing in general often distinguish between production code and test code. Questions like

How much care do we need to apply for test code?
But I write so much more test code than production code. Doesn’t that slow me down?
Isn’t it cumbersome to write all this complicated test code?

The truth is that there is no difference in the importance or relevance of production and test code. It is both code that helps you deliver the requested functionality to your client.

The truth is that your client asked you to deliver a product to solve his problem. And the solution should be correct, stable, and maintainable.

And this code, the code that solves the client’s problem, consists of functional code and test code, both add different aspects to the resulting product. So in the end, you have product code.

Go: the Good, the Bad and the Ugly

Tue, 17 Apr 2018 00:00:00 GMT

Sylvain Wallez summarizes his experiences with Go. The whole article is a pleasure to read and it maintains an impartial, non-judgemental perspective.

This struck me, as it reflects my experience as well.

Go creators deserve a lot of respect, but it looks like Go’s design happened in a parallel universe (or their Plan9 lab?) where most of what happened in compilers and programming language design in the 90’s and 2000’s never happened. Or that Go was designed by system programmers who were also able to write a compiler.

I really don’t get this. CPUs are getting faster and faster, so there’s almost no penalty to move checks, verifications, and guarantees into the compiler. Instead developers are forced to deal with stupid bugs that could be easily caught by the compiler.

Go’s goal was to replace C and C++, and it’s apparent that its creators didn’t look much elsewhere. They missed their target though, as C and C++ developers at Google didn’t adopt it. My guess is that the primary reason is the garbage collector. Low level C developers fiercely reject managed memory as they have no control on what happens and when. They like this control, even if it comes with additional complexity and opens the door to memory leaks and buffer overflows. Interestingly, Rust has taken a completely different approach with automatic memory management without a GC.

That’s really interesting. I don’t know where Sylvain got this insight from. But Google started as Python shop and it seems that still an important part of the development culture.

Let’s put it simply: there is no dependency management in Go. All current solutions are just hacks and workarounds.

This goes back its origins at Google, which famously uses a giant monolithic repository for all their source code. No need for module versioning, no need for 3rd party modules repositories, you build everything from your current branch. Unfortunately this doesn’t work in the open Internet.

I think this is a rather visible symptom of a bigger underlying issue. Go has been designed as Google’s programming language. It is intended to work best at Google.

★ Cloud Fibel 2.0

Wed, 28 Oct 2015 11:00:00 GMT

Wir sind davon überzeugt, dass verteilte, skalierbare und auf Microservices basierende Anwendungen die Zukunft der IT sind. Diese Anwendungen brauchen eine neue Generation von Infrastruktur, die häufig mit dem Begriff Cloud beschrieben wird. Die Cloud ist zur Zeit einer der stärksten Treiber von Veränderungen in der IT. So schwammig der Begriff ist, so vielfältig sind die neuen Technologien, die im Cloudumfeld aus dem Boden schießen.

Cloud Fibel 2.0

Mit der zweiten Auflage der Cloud Fibel, einer Sonderausgabe des Softwerkers, möchten wir die Technologien aufzeigen, die sich beim Betrieb privater Clouds für uns bewährt haben, mit denen wir eine private Cloud für die Firma CenterDevice erfolgreich umgesetzt haben und unsere eigene Cloud betreiben. Dazu stellen wir die Technologien im Detail vor und beschreiben ihren Einsatz in der Praxis.

Inhalte

Ganz konkret stellen wir die Virtualisierungsplattform OpenStack mit Docker, den Storage Cluster Ceph und das Provisionierungswerkzeug Ansible vor. OpenStack und Ceph sind mächtige Plattformen, die sich ergänzen und außergewöhnliche Leistung bieten. Docker ermöglicht auf effektive Art, Software zu bündeln und sie auf Entwickler-, Test- und Produktivsystemen mit wenigen Anpassungen zu betreiben. Ansible ist die neue Generation eines Provisionierungswerkzeugs, das speziell an die Bedürfnisse von Cloudumgebungen angepasst ist.

Darüber hinaus blicken wir auf die Platform-as-a-Service-Software OpenShift und beleuchten die Cloud aus Sicht der Softwareentwicklung anhand von Microservices. Zum Schluss zeigt eine nicht ganz ernst gemeinte Detektivgeschichte die Jagd nach einer Fehlkonfiguration in einer echten Cloud.

Frei verfügbar!

Die Cloud Fibel ist sowohl gedruckt als auch digital frei verfügbar. Sie lässt sich ganz einfach auf www.cloudfibel.de bestellen. Viel Spaß beim Lesen! Für alle Fragen, die offen bleiben, sind wir für Sie da.

Effectively Using Iterators In Rust

Tue, 23 Jun 2015 00:00:00 GMT

Herman J. Radtke III explains that combinators are only available on iterators. In order to apply combinators on any collection type, an iterator of a specific collection must be created first.

Iter

In Rust, you quickly learn that vector and slice types are not iterable themselves. Depending on which tutorial or example you see first, you call .iter() or .into_iter(). […] Most examples I have found use .iter(). We can call v.iter() on something like a vector or slice. This creates an Iter<'a, T> type and it is this Iter<'a, T> type that implements the Iterator trait and allows us to call functions like .map().

It’s important to understand that .iter() gives references to the collection’s elements. So, if the collection contains references, we end up with references of references:

fn use_names_for_something_else(_names: Vec<&str>) {
}

fn main() {
    let names = vec!["Jane", "Jill", "Jack", "John"];

    let total_bytes = names
        .iter()
        .map(|name: &&str| name.len())
        .fold(0, |acc, len| acc + len );

    assert_eq!(total_bytes, 16);
    use_names_for_something_else(names);
}
The closure used in map() does not require the name parameter to have a type, but I specified the type to show how it is being passed as a reference. Notice that the type of name is &&str and not &str. The string “Jane” is of type &str. The iter() function creates an iterator that has a reference to each element in the names vector. Thus, we have a reference to a reference of a string slice. This can get a little unwieldy and I generally do not worry about the type. However, if we are destructuring the type, we do need to specify the reference:
fn main() {
   let player_scores = [
       ("Jack", 20), ("Jane", 23), ("Jill", 18), ("John", 19),
   ];

   let players = player_scores
       .iter()
       .map(|(player, _score)| {
           player
       })
       .collect::<Vec<_>>();

   assert_eq!(players, ["Jack", "Jane", "Jill", "John"]);
}
In the above example, the compiler will complain that we are specifying the type (_, _) instead of &(_, _). Changing the pattern to &(player, _score) will satisfy the compiler.

IntoIter

Use the into_iter() function when you want to move, instead of borrow, your value.

How for Loops Actually Work

One of the first errors a new Rustacean will run into is the move error after using a for loop:
fn main() {
    let values = vec![1, 2, 3, 4];

    for x in values {
        println!("{}", x);
    }

    let y = values; // move error
}
The question we immediately ask ourselves is “How do I create a for loop that uses a reference?”. A for loop in Rust is really just syntatic sugar around .into_iter(). From the manual:
// Rough translation of the iteration without a `for` iterator.
let mut it = values.into_iter();
loop {
    match it.next() {
        Some(x) => println!("{}", x),
        None => break,
    }
}
Now that we know .into_iter() creates a type IntoIter<T> that moves T, this behavior makes perfect sense. If we want to use values after the for loop, we just need to use a reference instead:
fn main() {
    let values = vec![1, 2, 3, 4];

    for x in &values {
        println!("{}", x);
    }

    let y = values; // perfectly valid
}
Instead of moving values, which is type Vec<i32>, we are moving &values, which is type &Vec<i32>. The for loop only borrows &values for the duration of the loop and we are able to move values as soon as the for loop is done.

`core::iter::Cloned`

Sometimes it is necessary to clone certain elements of a collection. For example when a new collection containing filtered elements is required. In order to avoid unnecessary allocations, it’s cheaper to only clone the required elements instead of cloning the original collection and then filtering.

x.clone().into_iter() take(2).collect::<Vec<_>>(); // This is expensive
x.iter().map(|i| i.clone()).take(2).collect::<Vec<_>>(); // This is cheaper

For the second case there is a library function that allows the Rust compiler to optimize allocations for required elements only:

x.iter().cloned().take(2).collect::<Vec<_>>(); // This is the cheaper variant using `cloned()`

Strategies for solving ‘cannot move out of’ borrowing errors in Rust

Tue, 09 Jun 2015 00:00:00 GMT

Sometimes you hold on a reference even though you’re sure the reference is not used anymore. Nevertheless, the borrow checker does not let you move the owned variable. Consider this example:

fn main() {
  let name = " Herman ".to_string();
  let trimmed_name = name.trim(); // == &[1..n-1]
  let len = trimmed_name.len();

  somefunction_move(name, len); // The compiler won't like this!
}

The reason behind this is that variables and thus lifetimes are lexically scoped. As long as the variable is in the lexical scope, it’s lifetime is still alive.

Herman J. Radtke III presents three strategies for how to deal with this:

1. Block

You can limit the scope of a variable by embedding it its own block:

fn main() {
  let name = " Herman ".to_string();
  let len = {
    let trimmed_name = name.trim(); // == &[1..n-1]
    trimmed_name.len()
  }

  somefunction_move(name, len); // The compiler will be happy.
}

2. Closure

You can limit the scope of a variable my embedding it in a closure:

fn main() {
  let name = " Herman ".to_string();

  let f = |name: &str| {
    let trimmed_name = name.trim(); // == &[1..n-1]
    trimmed_name.len()
  };

  let len = f(&name);

  somefunction_move(name, len); // The compiler will be happy.
}

3. Function

You can limit the scope of a variable my embedding it in a closure:

fn f(name: &str) -> {
  let trimmed_name = name.trim(); // == &[1..n-1]
  trimmed_name.len()
};

fn main() {
  let name = " Herman ".to_string();

  let len = f(&name);

  somefunction_move(name, len); // The compiler will be happy.
}

Herman has a real world example at the end of his article.

★ Docker basiertes Runtime Environment for Developers

Wed, 03 Dec 2014 09:00:00 GMT

Verteilte, skalierbare, cloudfähige Anwendungen sind die Zukunft der Softwareentwicklung. Moderne Softwareprojekte basieren auf einer Vielzahl von Komponenten, um die fachliche Funktionalität schnell zu implementieren. Dies sind zum Beispiel verschiedene Datenbank- sowie Messaging-Systeme, Suchmaschinen und vieles mehr. Darüber hinaus werden Anwendung zunehmend verteilt betrieben, um Anforderungen an Antwortzeiten, Skalierbarkeit und Ausfallsicherheit gerecht zu werden. Dies stellt Softwareentwickler vor die Herausforderung, alle benötigten Komponenten auf ihrem Entwicklungssystem installieren und konfigurieren zu müssen, um so stets eine aktuelle und produktionsnahe Entwicklungsumgebung zu nutzen zu können. Eine ähnliche Herausforderung stellt sich dem Betriebsteam für die Pflege der Produktionsumgebung.

Für CenterDevice haben wir dazu eine Docker basierte Entwicklungsumgebung geschaffen, die den Entwicklern diese Arbeit abnimmt. In diesem Artikel stelle ich diese Entwicklungsumgebung vor.

Docker wurde bereits in den Artikeln 1, 2, 3, 4 und 5 vorgestellt. Der wesentliche Vorteil von Docker ist, dass Docker Images eigenständige Laufzeitumgebungen darstellen, die sowohl von Entwicklern als auch vom Betrieb in der Produktion eingesetzt werden können. Mein Kollege Alexander Berresch und ich haben uns diese Eigenschaft von Docker zunutze gemacht und eine Entwicklungsumgebung für die CenterDevice geschaffen, die vollständig auf Docker Images basiert.

Wir nennen diese Entwicklungsumgebung Runtime Environment for Development (RED) und setzten sie seit einem Jahr erfolgreich bei der Entwicklung von CenterDevice ein.

RED bei CenterDevice

Der Artikel The CenterDevice Cloud Architecture Revisited gibt einen Überblick über die Softwarearchitektur von CenterDevice und stellt die externen Komponenten wie MongoDB, RabbitMQ, ElasticSearch und Tomcat vor. Diese externen Komponenten werden in RED als Docker Images zentral gepflegt. Damit müssen unsere Entwickler für die täglich Arbeit lediglich aktualisierte Docker Images aus unserer zentralen private Docker Registry (siehe auch 3 und docker-registry) laden und können arbeiten, ohne zeitaufwendig ihre Entwicklungsumgebung zu pflegen.

Die eigenen Software Komponenten werden ebenfalls als Docker Images verpackt und anschließen als Container in RED gestartet. Es ist aber auch möglich, Komponenten in einem hybriden Modus zu starten, sodass die gerade zu entwickelnden Komponenten in der IDE und alle externen Komponenten in Docker Containern laufen.

Durch die Containerisierung aller Komponenten lässt sich eine produktionsnahe Entwicklungsumgebung schaffen, die Sharding und Replication von Datenbanken beinhaltet und in der Produktion eingesetzt werden kann. Des Weiteren bietet dieser Ansatz den Vorteil, dass neue Teammitglieder schnell eine vollständige Entwicklungsumgebung auf ihren Rechnern aufsetzen und somit schneller produktiv arbeiten können.

Technische Umsetzung

RED wurde speziell für CenterDevice von uns entwickelt. Die Prinzipien und die grundlegende technische Umsetzung können jedoch verallgemeinert und auf beliebige Projekte angewendet werden. Die Grundlagen für RED sind VirtualBox, Vagrant und Docker.

VirtualBox wird zur Virtualisierung genutzt, sodass RED betriebssystemunabhängig auf allen gängigen Betriebsystemen von Entwicklern eingesetzt werden kann. Vargant automatisiert den Umgang mit VirtualBox, sodass die Virtualisierung “head less” auf den Entwicklersystemen laufen kann. Docker erlaubt ein einfaches Deployment von Abhängigkeiten in Form von externen Komponenten sowie die Bündlung von Artefakten und Konfigurationen — siehe Abbildung 1.

Abbildung 1 zeigt eine Übersicht über die in RED eingesetzten Technologien.

Zukunft

Zur Zeit werden die Docker Images noch von den CenterDevice Entwicklern selbst gebaut und in unsere private Docker Registry geladen. In Zukunft möchten wir diesen Schritt in unsere Continuous Integration Pipeline einbauen und von Jenkins automatisch erledigen lassen. So können wir unsere Integrationstest ebenfalls auf Docker Images umstellen und damit eine bessere Isolation der Tests ermöglichen.

Es gibt noch mehr

Alexander Berresch wird in einem weiteren Artikel nächste Woche die technische Umsetzung genauer beschreiben und dazu ein kleines Beispiel auf GitHub veröffentlichen, so dass Ihr selbst ein RED für Eure eigenen Projekte aufsetzen könnt. Also bleibt dran und meldet Euch bei uns, falls Ihr Fragen oder Anregungen habt.

★ An OpenStack Crime Story solved by tcpdump, sysdig, and iostat – Episode 3

Wed, 17 Sep 2014 09:00:00 GMT

Previously on OpenStack Crime Investigation* … Two load balancers running as virtual machine in our OpenStack based cloud, sharing a* keepalived based highly available IP address started to flap, switching the IP address back and forth. After ruling out a misconfiguration of keepalived and issues in the virtual network, I finally got the hint that the problem might originate not in the virtual, but in the bare metal world of our cloud. Maybe high IO was causing the gap between the keep alive VRRP packets.

When I arrived at baremetal host node01, hosting virtual host loadbalancer01, I was anxious to see the IO statistics. The machine must be under heavy IO load when the virtual machine’s messages are waiting for up to five seconds.

I switched on my iostat flash light and saw this:

$ iostat
Device:            tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn
sda              12.00         0.00       144.00          0        144
sdc               0.00         0.00         0.00          0          0
sdb               6.00         0.00        24.00          0         24
sdd               0.00         0.00         0.00          0          0
sde               0.00         0.00         0.00          0          0
sdf              20.00         0.00       118.00          0        118
sdg               0.00         0.00         0.00          0          0
sdi              22.00         0.00       112.00          0        112
sdh               0.00         0.00         0.00          0          0
sdj               0.00         0.00         0.00          0          0
sdk              21.00         0.00        96.50          0         96
sdl               0.00         0.00         0.00          0          0
sdm               9.00         0.00        64.00          0         64

Nothing? Nothing at all? No IO on the disks? Maybe my bigger flash light iotop could help:

$ iotop

Unfortunately, what I saw was too ghastly to show here and therefore I decided to omit the screenshots of iotop¹. It was pure horror. Six qemu processes eating the physical CPUs alive in IO.

So, no disk IO, but super high IO caused by qemu. It must be network IO then. But all performance counters show almost no network activity. What if this IO wasn’t real, but virtual? It could be the virtual network driver! It had to be the virtual network driver.

I checked the OpenStack configuration. It was set to use the para-virtualized network driver vhost_net.

I checked the running qemu processes. They were also configured to use the para-virtualized network driver.

$ ps aux | grep qemu
libvirt+  6875 66.4  8.3 63752992 11063572 ?   Sl   Sep05 4781:47 /usr/bin/qemu-system-x86_64
 -name instance-000000dd -S ... -netdev tap,fd=25,id=hostnet0,vhost=on,vhostfd=27 ...

I was getting closer! I checked the kernel modules. Kernel module vhost_net was loaded and active.

$ lsmod | grep net
vhost_net              18104  2
vhost                  29009  1 vhost_net
macvtap                18255  1 vhost_net

I checked the qemu-kvm configuration and froze.

$ cat /etc/default/qemu-kvm
# To disable qemu-kvm's page merging feature, set KSM_ENABLED=0 and
# sudo restart qemu-kvm
KSM_ENABLED=1
SLEEP_MILLISECS=200
# To load the vhost_net module, which in some cases can speed up
# network performance, set VHOST_NET_ENABLED to 1.
VHOST_NET_ENABLED=0

# Set this to 1 if you want hugepages to be available to kvm under
# /run/hugepages/kvm
KVM_HUGEPAGES=0

vhost_net was disabled by default for qemu-kvm. We were running all packets through userspace and qemu instead of passing them to the kernel directly as vhost_net does! That’s where the lag was coming from!

I acted immediately to rescue the victims. I made the huge, extremely complicated, full 1 byte change on all our compute nodes by modifying a VHOST_NET_ENABLED=0 to a VHOST_NET_ENABLED=1, restarted all virtual machines and finally, after days of constantly screaming in pain, the flapping between both load balancers stopped.

I did it! I saved them!

But I couldn’t stop here. I wanted to find out, who did that to the poor little load balancers. Who’s behind this conspiracy of crippled network latency?

I knew there was only one way to finally catch the guy. I set a trap. I installed a fresh, clean, virgin Ubuntu 14.04 in a virtual machine and then, well, then I waited — for apt-get install qemu-kvm to finish:

$ sudo apt-get install qemu-kvm
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following extra packages will be installed:
  acl cpu-checker ipxe-qemu libaio1 libasound2 libasound2-data libasyncns0
  libbluetooth3 libboost-system1.54.0 libboost-thread1.54.0 libbrlapi0.6
  libcaca0 libfdt1 libflac8 libjpeg-turbo8 libjpeg8 libnspr4 libnss3
  libnss3-nssdb libogg0 libpulse0 librados2 librbd1 libsdl1.2debian
  libseccomp2 libsndfile1 libspice-server1 libusbredirparser1 libvorbis0a
  libvorbisenc2 libxen-4.4 libxenstore3.0 libyajl2 msr-tools qemu-keymaps
  qemu-system-common qemu-system-x86 qemu-utils seabios sharutils
Suggested packages:
  libasound2-plugins alsa-utils pulseaudio samba vde2 sgabios debootstrap
  bsd-mailx mailx
The following NEW packages will be installed:
  acl cpu-checker ipxe-qemu libaio1 libasound2 libasound2-data libasyncns0
  libbluetooth3 libboost-system1.54.0 libboost-thread1.54.0 libbrlapi0.6
  libcaca0 libfdt1 libflac8 libjpeg-turbo8 libjpeg8 libnspr4 libnss3
  libnss3-nssdb libogg0 libpulse0 librados2 librbd1 libsdl1.2debian
  libseccomp2 libsndfile1 libspice-server1 libusbredirparser1 libvorbis0a
  libvorbisenc2 libxen-4.4 libxenstore3.0 libyajl2 msr-tools qemu-keymaps
  qemu-kvm qemu-system-common qemu-system-x86 qemu-utils seabios sharutils
0 upgraded, 41 newly installed, 0 to remove and 2 not upgraded.
Need to get 3631 kB/8671 kB of archives.
After this operation, 42.0 MB of additional disk space will be used.
Do you want to continue? [Y/n] <
...
Setting up qemu-system-x86 (2.0.0+dfsg-2ubuntu1.3) ...
qemu-kvm start/running
Setting up qemu-utils (2.0.0+dfsg-2ubuntu1.3) ...
Processing triggers for ureadahead (0.100.0-16) ...
Setting up qemu-kvm (2.0.0+dfsg-2ubuntu1.3) ...
Processing triggers for libc-bin (2.19-0ubuntu6.3) ...

And then, I let the trap snap:

$ cat /etc/default/qemu-kvm
# To disable qemu-kvm's page merging feature, set KSM_ENABLED=0 and
# sudo restart qemu-kvm
KSM_ENABLED=1
SLEEP_MILLISECS=200
# To load the vhost_net module, which in some cases can speed up
# network performance, set VHOST_NET_ENABLED to 1.
VHOST_NET_ENABLED=0

# Set this to 1 if you want hugepages to be available to kvm under
# /run/hugepages/kvm
KVM_HUGEPAGES=0

I could not believe it! It was Ubuntu’s own default setting. Ubuntu, the very foundation of our cloud decided that despite all modern hardware supporting vhost_net to turn it off by default. Ubuntu was convicted and I could finally rest.

This is the end of my detective story. I found and arrested the criminal Ubuntu default setting and were able to prevent him from further crippling our virtual network latencies.

Please feel free to leave comments and ask questions about details of my journey. I’am already negotiating to sell the movie rights. But maybe there will be another season of OpenStack Crime Investigation in the future. So stay tuned on codecentric Blog.

Footnotes

1. Eh, and because I lost them.↵

★ An OpenStack Crime Story solved by tcpdump, sysdig, and iostat – Episode 2

Tue, 16 Sep 2014 09:00:00 GMT

Previously on OpenStack Crime Investigation*. I was called to a crime scene; our OpenStack based private cloud for CenterDevice. Somebody or something was causing our virtual load balancers to flap their highly available IP address.* tcpdump showed me that there were time gaps between the keepalive VRRP packets. And these gaps originated on the first hop, the master load balancer.

After discovering the culprit might be hiding inside the virtual machine, I fetched my assistant sysdig and we ssh’ed into loadblancer01. Together, we started to ask questions; very intense, uncomfortable questions to finally get to the bottom of this.

sysdig is a relatively new tool that basically traces all syscalls and uses Lua scripts - called chisels - to derive conclusions about the captured sequence of syscalls. In general, it is like tcdump for syscalls. Since every process that wants to do anything useful has to use syscalls, a very detailed view of your system’s behavior evolves. sysdig is developing into a serious swiss army knife and you should give it a try; especially, read these three blog post to learn about sysdig’s capabilities which convinced me.

sysdig being the good detective assistant went to work immediately and kept a transcript about all questions and answers in a file.

$ sysdig -w transcript

I was especially interested in the sendmsg syscall that actually sends network packets issued by the keepalived process.

After a syscall is invoked by a process, the process is paused until the syscall has been finished by the kernel and only then the execution of the process is resumed.

I was interested in the invocation, that is the event direction from user process to kernel.

$ sysdig -r transcript proc.name=keepalived and evt.type=sendmsg and evt.dir='>'

That stirred up quite some evidence. But I wanted to find the time gaps larger than one second. I drew Lua from my concealed holster inside my jacket and fired a quick chisel right between two sendmsg syscalls:

$ sysdig -r transcript -c find_time_gap proc.name=keepalived and evt.type=sendmsg and evt.dir='>'
370964 17:01:26.375374738 (5.03543187) keepalived > sendmsg fd=13(192.168.205.8->224.0.0.18) size=40 tuple=0.0.0.0:112->224.0.0.18:0

Got you! A time gap of more than five seconds turned up. I inspected the events closely looking for event number 370964.

$ sysdig -r transcript proc.name=keepalived and evt.type=sendmsg and evt.dir='>' | grep -C 1 370964
368250 17:01:21.339942868 0 keepalived (10400) > sendmsg fd=13(192.168.205.8->224.0.0.18) size=40 tuple=0.0.0.0:112->224.0.0.18:0
370964 17:01:26.375374738 1 keepalived (10400) > sendmsg fd=13(192.168.205.8->224.0.0.18) size=40 tuple=0.0.0.0:112->224.0.0.18:0
371446 17:01:26.377770247 1 keepalived (10400) > sendmsg fd=13(192.168.205.8->224.0.0.18) size=40 tuple=0.0.0.0:112->224.0.0.18:0

There, in lines 1 and 2. There it was. A gap much larger than one second. Now it was clear. The perpetrator was hiding inside the virtual machine causing lags in the processing of keepalived’s sendmsg. But who was it?

After some ruling out of innocent bystanders, I found this:

$ sysdig -r transcript | tail -n +368250 | grep -v "keepalived\|haproxy\|zabbix"
369051 17:01:23.621071175 3  (0) > switch next=7 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369052 17:01:23.621077045 3  (7) > switch next=0 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369053 17:01:23.625105578 3  (0) > switch next=7 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369054 17:01:23.625112785 3  (7) > switch next=0 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369055 17:01:23.628568892 3  (0) > switch next=25978(sysdig) pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369056 17:01:23.628597921 3 sysdig (25978) > switch next=0 pgft_maj=0 pgft_min=2143 vm_size=99684 vm_rss=6772 vm_swap=0
369057 17:01:23.629068124 3  (0) > switch next=7 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369058 17:01:23.629073516 3  (7) > switch next=0 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369059 17:01:23.633104746 3  (0) > switch next=7 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369060 17:01:23.633110185 3  (7) > switch next=0 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369061 17:01:23.637061129 3  (0) > switch next=7 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369062 17:01:23.637065648 3  (7) > switch next=0 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369063 17:01:23.641104396 3  (0) > switch next=7 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369064 17:01:23.641109883 3  (7) > switch next=0 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369065 17:01:23.645069607 3  (0) > switch next=7 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369066 17:01:23.645075551 3  (7) > switch next=0 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369067 17:01:23.649071836 3  (0) > switch next=7 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369068 17:01:23.649077700 3  (7) > switch next=0 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369069 17:01:23.653073066 3  (0) > switch next=7 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369070 17:01:23.653078791 3  (7) > switch next=0 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369071 17:01:23.657069807 3  (0) > switch next=7 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369072 17:01:23.657075525 3  (7) > switch next=0 pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369073 17:01:23.658678681 3  (0) > switch next=25978(sysdig) pgft_maj=0 pgft_min=0 vm_size=0 vm_rss=0 vm_swap=0
369074 17:01:23.658698453 3 sysdig (25978) > switch next=0 pgft_maj=0 pgft_min=2143 vm_size=99684 vm_rss=6772 vm_swap=0

The processes masked behind pids 0 and 7 were consuming the virtual CPU. 0 and 7? These low process ids indicate kernel threads! I double checked with sysdig’s supervisor, just to be sure. I was right.

The kernel, the perpetrator? This hard working, ever reliable guy? No, I could not believe it. There must be more. And by the way, the virtual machine was not under load. So what could the virtual machine’s kernel be doing … except … it was not doing anything at all? Maybe it was waiting for IO! Could that be? Since all hardware of a virtual machine is, well, virtual, the IO wait could only be on the baremetal level.

I left loadbalancer01 for its bare metal node01. On my way,* *I was trying to wrap my head around what was happening. What is this all about? So many proxies, so many things happening in the shadows. So many false suspects. This is not a regular case. There is something much more vicious happening behind the scene. I must find it …

Stay tuned for our all new, next and final episode of OpenStack Crime Investigation* tomorrow on codecentric Blog.*

★ An OpenStack Crime Story solved by tcpdump, sysdig, and iostat - Episode 1

Mon, 15 Sep 2014 09:00:00 GMT

This is the story of how the tiniest things can sometimes be the biggest culprits. Because first and foremost, this is a detective story. So come and follow me on a little crime scene investigation that uncovered an incredibly counterintuitive and almost criminal default setting in Ubuntu 14.04 crippling the virtual network performance and especially network latency.

And just in case you don’t like detective stories - and this goes out to all you nerds out there - I promise it will be worth your while, because this is also an introduction to keepalived, tcpdump, and sysdig. So sit back and enjoy!

The problems came out of the blue. We are running an OpenStack installation for the next generation CenterDevice cloud.

CenterDevice is a cloud-based document solution and our clients rely on its 24/7 availability. In order to achieve this availability, all our components are multiply redundant. For example, our load balancers are two separate virtual machines running HAProxy. Both instances manage a highly available IP address via keepalived.

This system worked very well. Until both load balancers became the victims of an evil crime. Both virtual machines started flapping their highly available virtual IP address and we were receiving alerting e-mails by the dozens, but there was no obvious change to the system that could have explained this behavior.

And this is how the story begins.

When I was called to investigate this weird behavior and answer the question what was happening to the poor little load balancers, I started by taking a good close look at the crime scene: keepalived. The following listing shows our master configuration of keepalived on virtual host loadbalancer01¹.

% sudo cat /etc/keepalived/keepalived.conf
global_defs {
        notification_email {
                some-e-mail-address@veryimportant.people
        }
        notification_email_from loadbalancer01@protecting.the.innocent.local
        smtp_server 10.10.9.8
        smtp_connect_timeout 30
        router_id loadbalancer01
}

vrrp_script chk_haproxy {
        script "killall -0 haproxy"
        interval 2
        weight 2
}

vrrp_instance loadbalancer {
        state MASTER
        interface eth0
        virtual_router_id 205
        priority 101
        smtp_alert
        advert_int 1
        authentication {
                auth_type PASS
                auth_pass totally_secret
        }
        virtual_ipaddress {
                192.168.205.7
        }
        track_script {
                chk_haproxy
        }
}

The same configuration on our second load balancer loadbalancer02 looks exactly the same with notification email and router id changed accordingly as well as a lower priority. This all looked fine to me and it was immediately clear that keepalived.conf was not the one to blame. I needed to figure out a different reason why the two keepalived were continuously flapping the virtual IP address.

Now, it is important to understand how VRRP, the protocol keepalived uses to check the availability of its partners, work. All partners continuously exchange keep alive packets via the multicast address vrrp.mcast.net which resolves to 224.0.0.18. These packets use IP protocol number 112. Only if the backup does not receive these keep alive packets from the current master, it assumes the partner is dead, murdered, or otherwise gone AWOL and takes over the virtual IP address, now acting as the new master. If the old master decides to check back in, the virtual IP address is exchanged again.

Since we were observing this exchange back and forth, I suspected the virtual network to unlawfully disregard its responsibility. I immediately rushed to the terminal and started to monitor the traffic. This might seem easy, but it is far more complex than you think. The figure below, taken from openstack.redhat.com, shows on overview of how Neutron creates virtual networks.

OpenStack Neutron Architecture [https://openstack.redhat.com/Networking_in_too_much_detail]

Since both load balancers were running on different nodes, the VRRP packets traveled from A to J and back to Q. So where to look for the missing packets?

I decided to tail the packets at A, E, and J. Maybe that was where the culprit was hiding. So I started tcpdump on loadbalancer01, the compute node node01, and the network controller control01 looking for missing packets. And there were packets, I tell you. Lots of packets. But I could not see missing packets until I stopped tcpdump:

$ tcpdump -l host vrrp.mcast.net
...
45389 packets captured
699 packets received by filter
127 packets dropped by kernel

Dropped packets by the kernel? Are these our victims? Unfortunately not.

tcpdump uses a little buffer in the kernel to store captured packets. If too many new packets arrive before the user process tcpdump can decode them, the kernel drops them to make room for freshly arriving packets.

Not very helpful when you are trying to find where packets get, well, dropped. But there is the handy parameter -B for tcpdump that increases this buffer. I tried again:

$ tcpdump -l -B 10000 host vrrp.mcast.net

Much better, no more dropped packets by the kernel. And now, I saw something. While the VRRP packets were dumped on my screen, I noticed that sometimes there was a lag of more than one second between VRRP keep alives. This struck me as odd. This should not happen as the interval for VRRP packets has been set to one second in the configurations. I felt that I was on to something, but just needed to dig deeper.

I let tcpdump show me the time differences between succeeding packets and detect differences bigger than one second.

$ tcpdump -i any -l -B 10000 -ttt host vrrp.mcast.net  | grep -v '^00:00:01'

Oh my god. Look at the screenshot above². There is a delay of more than 3,5 seconds. Of course loadbalancer02 assumes his partner went MIA.

But wait, the delay already starts on loadbalancer01? I have been fooled! It is not the virtual network. It had to be the master keepalived host! But why? Why should the virtual machine hold packets back? There must be some evil hiding in this machine and I will find and face it…

Stay tuned for our all new next episode of OpenStack Crime Investigation* tomorrow on the codecentric Blog.*

Footnotes

1. All personal details like IP, E-Mail addresses etc. have been changed to protect the innocent.↵
2. Yes, you see correctly. I am running screen inside tmux . This allows me to sustain the screen tabs even during logouts.↵

★ Drei Tage ScalaDays 2014 im Überblick

Sat, 05 Jul 2014 09:00:00 GMT

Der Fokus der ScalaDays 2014 in Berlin lag auf Vereinfachung, Reactive Streams und Event Sourcing mit Akka Persitence. Vom 16. bis

Juni trafen sich dazu Entwickler und konnten 59 Vorträgen in mehreren Tracks zuhören. Die Vorträge waren ein spannende Mischung aus theoretischen und praktischen Themen sowie eindrucksvollen War Stories. In diesem Artikel stelle ich meine Mischung vor und berichte, was bei mir die stärksten Eindrücke hinterlassene hat.

Edit: Mittlerweile sind die Vorträge als Videos bei Parleys verfügbar.

Vereinfachung

Martin Odersky hat in seiner Keynote Scala: The Simple Parts über den neuen Scala Compiler dotc gesprochen, der neben besserer Performance auch eine Vereinfachung der Sprache bringen soll. So sind einige Sprachkonstrukte wie Implicit Conversions und einige Typenspezifika nur über Feature Flags zu aktivieren. Er sprach aber auch über seine 7 Scala Muster, die er bei der täglichen Arbeit nutzt. Interessant fand ich seine Bemerkung, dass er Scala nicht als object/functional Sprache ansieht, sondern als modulare Sprache. Gerade erst die Kombination von objektorientierten und funktionalen Aspekten erleichtern Modularisierung.

Reactive Streams

Das Akka Team arbeitet an der Integration von eventsourced und Spray.io als neue Module namens Akka Persistence bzw. Akka HTTP. Gerade diese beiden Module werden als Basis für viele andere Projekte herbeigesehnt. Zum Beispiel beabsichtigt das Play Team mit diesen Modulen ihre Iteratee Implementierung und Netty als Webserver zu ersetzen.

Überhaupt hat das Play Team in seiner Vorstellung von Play 2.4 viel über die Modularisierung von Play in einzelne Komponenten wie zum Beispiel sbt-web und die Templating Engine Twirl gesprochen. Diese Aufteilung von Play soll zum Einen die zukünftige Entwicklung beschleunigen und zum Anderen einzelne Komponenten austauschbar machen.

Ein besonderes Highlight war Nilanjan Raychaudhuri Vortrag zu Play Recipes for the Real World zu Best Practises für Play. Als Koch in Kochschürze wirbelte er energiegeladen durch den Raum und schaffte es noch dabei mit Live Coding zwei hoch performante Play Muster vorzustellen. Leider ist ihm die Zeit davon gelaufen, so dass er ein drittes nicht mehr zeigen konnte.

Matthias Nehlsen stellte in seinem Vortrag Writing Reactive Applications for Fun zwei seiner Open Source Projekte vor. BirdWatch zeigt alle Twitter Tweets zu einem bestimmten Suchbegriff in Echtzeit an. Es ist mit Play, Iteratees und ElasticSearch erstaunlich einfach und mit wenigen Zeilen umgesetzt.

Event Sourcing mit Akka Persitence

Das Akka Team demonstrierte im Vortrag Resilient Applications with Akka Persistence die Grundlagen von Akka Persistence und wie man damit Event und Command Sourcing umsetzt. Mit Hilfe von Akka Persistence ist es möglich, eintreffende Anfragen automatisch zu persistieren, bevor man sie verarbeitet. Im Fall eines Systemabsturzes wird der Systemzustand anhand des Logs wiederhergestellt.

Duncan DeVore stellte Building a Reactive Application vor, wie er und sein Team die Erfassung von Stromverbrauchsdaten mit Event Sourcing und Akka Persistence umgesetzt haben. Sie starteten dabei mit einer klassischen, auf JPA basierten Architektur, die der Last nicht gewachsen war. Durch die Umstellung auf Scala und Akka konnten sie diese Probleme lösen.

Etc

Im Live Coding DI w/o Frameworks hat Adam Waski MacWire vorgestellt. MacWire ist eine kleine Bibliothek um ein Scala Makro herum, dass Dependency Injection vollständig mit Scala Bordmitteln löst und mit Play kompatible ist. Philipp Haller diskutierte den Unterschied zwischen Scalas Future sowie Promise und seiner Async Bibliothek – Futures and Async: When to Use Which?. Insbesondere wenn man mit mehreren Futuren arbeitet, erleichtert Async die Übersichtlichkeit und das Verständnis des Codes. Eric Torreborre gab eine geniale Einführung in das Testing Framework Specs2 2.3. In 45 Minuten hat er tatsächlich alles gezeigt, was Specs2 so besonders macht und wie man es nutzt.

Als Randnotiz ist mir aufgefallen, dass fast alle Vortragenden Macs benutzen und wenn sie Live Coding gezeigt haben, IntelliJ verwendeten.

★ Provisioning IaaS Clouds with Dynamic Ansible Inventories and OpenStack Metadata

Wed, 25 Jun 2014 09:00:00 GMT

My colleague Daniel Schneller gave an introduction to Ansible. A key concept of Ansible is the inventory. It contains all hosts of your site that you want to provision with Ansible. For bare metal hardware, this inventory is a static file enumerating all your nodes. But what do you do when you want to provision Virtual Machines? They tend to come up and go down, multiply and reduce in numbers. Maintaining a static file is cumbersome in this situation. In addition to the mere enumeration, you need to specify the role each virtual node should play. In this article, I present how to build dynamic inventories by querying OpenStack for available Virtual Machines and using metadata to specify the roles for each of them in a dynamic fashion. A fully working example is available on GitHub to get you started with your own dynamic inventories.

Inventories in a Static World

An Ansible inventory consists of host groups enumerating hosts which belong to that group as well as specifying host based variables. These groups are used by Ansible playbooks to associate roles with the respective hosts. A specific host may be part of several groups in order to indicate that it takes several roles. Listing 1 shows a simple inventory where the two nodes node01 and node02 belong to two different host groups and have host based variables associated.

[openstack_compute_nodes]  
node01  
node02  

[dns_clients]  
node01 DNS_SERVER=192.168.0.10  
node02 DNS_SERVER=192.168.0.10

Inventories in a Dynamic World

The inventory in listing 1 suits a static environment where changes occur only rarely. But in an highly dynamic virtual environment where VMs come and go, keeping a static inventories is infeasible. For example, imagine that you run a central DNS server for all virtual machines. So every time a new virtual machine is started, Ansible should provision this DNS server as part of the new VM’s setup. Further, the services the VM should provide need to be provisioned, too. This means we need to first discover the machine, second gather which roles it shall play, and third, provision these roles to the machine.

In the next three paragraphs, we show you how to use OpenStack Metadata, some custom Python, and Ansible’s dynamic inventory feature to solve this challenge in a fully automatic fashion.

Metadata for OpenStack Virtual Machines

In OpenStack, a virtual machine may be annotated with arbitrary metadata. Figure 1 shows a screenshot from OpenStack’s Dashboard presenting metadata of a running instance.

Figure 1

This metadata can be added to an instance via command line while booting the instance. You can find a complete example on GitHub.

nova boot --flavor m1.medium … --meta
ansible_host_vars=dns_server_for_domains->v.clusterb.centerdevice.local,  
infrastructure.v.clusterb.centerdevice.local
--meta ansible_host_groups=admin_v_infrastructure

It is also possible to add metadata to an already running instance with the comannd nova meta <instance name> set <key=value>.

In general, you can set the metadata of an instance to arbitrary strings. In this examples, I use a key value pair like convention to specify two pieces of metadata information, i.e., ansible_host_vars and ansible_host_groups which are used by the dynamic inventory to fill the corresponding Ansible inventory values.

Dynamic Inventories for Ansible

An inventory is passed to the command ansible-playbook via the parameter -i. This inventory may be a static file or an executable. In case of the latter, Ansible requires the executable to return a JSON document. The corresponding JSON document for the metadata specified above looks like this:

➜  ./openstack_inventory.py
{
    "admin_v_infrastructure": {
        "hosts": [
            "192.168.0.10"
        ]
    },
    "_meta": {
        "hostvars": {
            "192.168.0.10": {
                "dns_server_for_domains": [
                    "v.clusterb.centerdevice.local",
                    "infrastructure.v.clusterb.centerdevice.local"
                ]
            }
        }
    }
}

You can see the general structure that is required. There are two sub documents admin_v_infrastructure and _meta. The first represents a host group of the same name and the second collects host variables for each host. For details about the JSON structure see the Ansible documentation.

In this way, we can assign a role for a DNS server to the hosts of host group admin_v_infrastructure while the host variable dns_server_for_domains specify for which domains the DNS server is responsible.

Querying OpenStack Metadata with Python

OpenStack is developed using Python, so all required Python modules needed to query OpenStack for instance metadata are already installed. The main function of the script looks like this:

def main(args):  
  credentials = getOsCredentialsFromEnvironment()  
  nt = client.Client(credentials['USERNAME'],
    credentials['PASSWORD'],
    credentials['TENANT_NAME'],
    credentials['AUTH_URL'],
    service_type="compute")  

  inventory = {}  
  inventory['_meta'] = { 'hostvars': {} }  

  for server in nt.servers.list():  
      floatingIp = getFloatingIpFromServerForNetwork(server,
        OS_NETWORK_NAME)  
      if floatingIp:  
          for group in getAnsibleHostGroupsFromServer(nt, server.id):
              addServerToHostGroup(group, floatingIp, inventory)  
          host_vars = getAnsibleHostVarsFromServer(nt, server.id)  
          if host_vars:
              addServerHostVarsToHostVars(host_vars, floatingIp, inventory)  

  dumpInventoryAsJson(inventory)

The script assumes that the environment variables OS_AUTH_URL, OS_USERNAME, OS_PASSWORD, and OS_TENANT_NAME are set in the same way as for all OpenStack command line utilities. In this example, we only provision VMs with a floating IP, because only those are accessible from outside their project. For all instances with a floating IP, the metadata is checked for the variables introduced above and if found added to the dynamic inventory. This inventory is dumped to stdout in JSON format. See the GitHub repository for details.

Using Multiple Inventories for Ansible

Ansible does not restrict you to use either a dynamic or static inventory. It is quite easily possible to combine multiple inventories, static as well as dynamic, by placing the files into a directory and passing the directory via the parameter -i. In this case, Ansible combines all inventories from files and executable results into one inventory.

Please pay attention when using a dictionary based inventory especially when using a dynamic inventory. Since all discovered hosts are added to the all host group, playbooks referring to this group might be unintentionally applied to hosts you have not been thinking of when writing the playbook.

There is more

Ansible is a highly flexible but still simple to use provisioning tool. In our document management cloud CenterDevice Ansible is replacing Puppet as our tool of choice. The ability to mix static and dynamic inventories to manage host groups and automatically provision new hosts by simply checking their metadata prove Ansible’s flexibility.

★ Crypto is Broken or How to Apply Secure Crypto as a Developer

Wed, 05 Mar 2014 08:00:00 GMT

Last year’s revelations show that crypto is broken on all levels.¹ We cannot trust hardware nor commercial software providers anymore to securely encrypt our data. My first instinct as a developer is to turn to open source libraries which have been tested and validated by the community. Unfortunately, unless you are a crypto expert, it is tremendously difficult to get it right as my experiment shows.

In this article I outline why it is virtually impossible to use regular open source crypto libraries like OpenSSL and how we can start to fix crypto using the NaCl library. I complement this article with a GitHub project demonstrating how to encrypt messages with state of the art crypto in a secure way.

So why is it so hard to implement crypto functionality? Let me take you with me on a little experiment in which I encrypt a message securely.

Hybrid Encryption

The state of the art in securely exchanging messages is called hybrid cryptography. It works in three steps. First, you take a message and encrypt it with a random symmetric key. Second, the symmetric key is encrypted with the asymmetric public key(s) of your recipient(s). This way, you have the security of asymmetric key exchange and the performance of symmetric encryption.² At last, you send the encrypted symmetric key and a signature in a so called envelope together with the symmetrically encrypted data.

It’s Bad — The Assembler For Crypto Code

I started my experiment with the standard open source crypto library: OpenSSL. It is the crypto foundation of a plethora of software products and has a native C API with bindings for almost all programming languages.

But this library — as others of its kind — only offers the most primitive crypto routines. The number of steps to implement hybrid encryption with OpenSSL is mind-boggling. And each step consists of multiple function calls, memory allocations, error handling, and format transformations:

Choose algorithms and parameters, e.g. AES 256 bit, RSA 4096 bit etc.
Generate RSA key pair
Generate random AES key and nonce³
Use AES key to encrypt data
Hash encrypted data
Read RSA private key from wire format
Use key to sign hash
Read recipient’s public key from wire format
Use public key to encrypt AES key and signature

This approach is like using assembler to write your application: cumbersome and error-prone. There are so many possible mistakes.

For example, the developers of Bitcrypt, a malware that encrypts your hard drive and blackmails you to pay for the decryption key in BitCoins, used a 128 byte (1024 bits) RSA encryption theme. At least that’s what they thought. As reverse engineers found out, they only used a 128 digits long number. This mistake rendered the crypto to 426 bit RSA which was broken in under 48 hours.

It Gets Worse — The Black Magic

But it still gets worse. Even after you got the code right, the journey to secure encryption does not get any easier. You may select wrong parameters, e. g. random values for nonces and key generation. Or did you know that the standard glib random function is based on LFSR and thus easily predictable and inherently insecure?

What about generating a asymmetric key pair? Here you go. Let’s create an RSA key pair with OpenSSL:

int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb);

You need to pass a buffer to write the key to (*rsa), the key length to generate in bits (bits), an exponent (*e), and a call back (*cb) in case you want to generate the key asynchronously. Wait a minute. An exponent? What’s that and how can I pick a value for it?

The documentation "The exponent is an odd number, typically 3, 17 or 65537”. Alright, typically. So can I choose 42? Of course not! It turns out that everything but 65537 is considered insecure by today’s standards. This is like black magic!

Selecting random values and generating an RSA key are just the first two steps of the above list. Seven more to screw up.

Abstraction to the Rescue — NaCl

So we should agree that OpenSSL is only useful for crypto experts. The rest of us need a simpler abstraction. Fortunately, Daniel Bernstein (djb)⁴ and his colleagues did not only point out the problem, they also offer a solution. They have created a high performance, open source crypto library called NaCl (pronounced salt) that gives us exactly what we need: A simple to use and secure API for crypto.

Opinionated Library

NaCl is an opinionated library. It gives us access to the secure application of cryptography, because it has predefined settings and therefore saves us from learning black magic. The authors chose three algorithms and the corresponding parameters: curve25519 for elliptic curve asymmetric encryption, Salsa20 for symmetric encryption, and poly1305 for message authentication.

Even though these algorithms are not as commonly known as RSA and AES, they are widely adopted for crypto tasks and have been crypto-analyzed during open contests like eSTREAM. Curve25519 uses smaller keys and is faster than RSA. Salsa is way faster than AES.

Salty API

NaCl currently only offers C and C++ APIs. Remember the nine steps plus function calls above? In order to achieve the hybrid encryption described above, all we need with NaCl are three function calls.

Let me show you how to encrypt and decrypt with NaCl:

// Create asymmetric key pair  
crypto_box_keypair(public_key, secret_key);
// Pick a symmetric key and a nonce, then symmetrically encrypt the message
crypto_secretbox(ciphertext, message, message_len, nonce, key);
// Pick another nonce and then asymmetrically encrypt key with nonce2,
// public key of recipient, and secret key of sender
crypto_box(enc_key, key, key_len, nonce2, reciepient_public_key, sender_secret_key);

Creating a key and a nonce requires random data. On Unix based systems you can read either from /dev/random (truly random, but may block if not enough randomness is available) or /dev/urandom. When in doubt, always use /dev/random — see below.

Now you can send the envelope (enc_key, nonce) as well as the encrypted message (ciphertext) to the recipient. NaCl automatically takes care of computing the message authentication for both symmetric and asymmetric encryption. Therefore, the ciphertext buffer always has to be crypto_secretbox_MACBYTES or crypto_box_MACBYTES bytes larger than the original message to fit the MAC.

To decrypt the message, there are two more functions:

// Decrypt symmetric key
crypto_box_open(key, enc_key, enc_key_len, nonce2, sender_public_key, recipient_secret_key);
// Use symmetric key to decrypt message
crypto_secretbox_open(message, ciphertext,ciphertext_len, nonce, key);

libsodium

NaCl is highly optimized and uses your processor’s capabilities to their maximum. For this, you need to compile NaCl for your specific hardware. This makes NaCl difficult to distribute as a binary. Fortunately, the authors of DNSCrypt created a wrapper library called libsodium that facilitates the use of NaCl on various platforms, even for iOS and Android. There are also bindings for various programming languages like Java, Python, Erlang etc.

Moreover libsodium adds the function randombytes_buf that fills a buffer with random data. You can configure libsodium during build time to use /dev/random or /dev/urandom with the configure parameter —enable-blocking-random.

Shick Crypto Library

NaCl already uses the hybrid approach in crypto_box, but only allows for one recipient. In order to demonstrate how easy it is to use NaCl, I implemented a tiny C wrapper around libsodium. This wrapper allows you to specify multiple recipients for a message. It is open source and available at GitHub. It consists of six high level functions for easily creating keys, encrypting, and decrypting messages. It also contains unit and acceptance tests as well as an example.

Please feel free to use and adapt it to your needs. If you encounter a bug or even a code smell, please send me a pull request, I’ll happily apply it.

There’s more

This article shows how difficult it is to get crypto right, even if you have the best intentions. It is insufficient to just use the right libraries. OpenSSL is one example. Most crypto libraries suffer from the same problem. You must truly understand how crypto works in all its details to implement it correctly and securely with these libraries.

NaCl and libsodium offer a simple way to avoid knowing all the nasty details while providing strong crypto for the rest of us. So give it a shot and try my library or take libsodium and NaCl directly for a spin. It’s easy and really secure.

Feel free to contact me if you have questions and comments.

Footnotes

1. At CCC 30, Daniel J. Bernstein and his colleagues explained how much this is true by showing that crypto standards like NIST FIPS 186-2 have possible backdoors and that even chip vendors like Intel cannot guarantee backdoor free crypto circuits.↵
2. Due to the usually larger key size of asymmetric encryption, it is computationally more expensive than symmetric encryption. Hybrid encryption is usually used when asymmetric encryption is applied, e.g. PGP/GPG, SSL/TLS.↵
3. A nonce is a additional random bit string added to the key before encryption or decryption. Using a nonce guarantees that no two messages lead to the same cipher text using the same key. This makes crypto analysis more difficult.↵
4. djb invented TCP Syn Cookies and qmail.↵

★ Ceph Object Storage as fast as it gets or Benchmarking Ceph

Mon, 03 Mar 2014 08:00:00 GMT

CenterDevice is a distributed document management and sharing software without any single centralized component. In our next evolution we are going to use the distributed object store Ceph for storing our encrypted documents. In this article, my colleague Daniel Schneller and I present benchmarks for CenterDevice’s current Ceph installation. As it turns out, Ceph is as fast as it gets. In fact, Ceph gives you a reliable, cheap, and performant alternative to commercial SANs and distributed file storage.

Setup

We use four Dell PowerEdge 510 servers with 128 GB RAM and 14x4 TB disks — two mirrored disks for the OS and 12 disks for Ceph storage. The servers are connected via 4x1 Gbit network interfaces with two redundant switches. Two network interfaces each are bonded to form a high availability link according to IEEE 802.3ad. This way, a link or switch can fail while connectivity continues over the other link. Furthermore, using layer 3+4 link aggregation via LACP, different TCP streams may use both links, enhancing network throughput.

Before measuring Ceph’s Object Store performance, we establish a baseline for the expected maximum performance by measuring the performance of the disks and the network.

Baseline - Disk

For the disk performance baseline, we proceed in two steps. First, we measure the performance of a single disk. Second, we determine the performance of the whole disk subsystem of one server by stressing all disks at once.

To determine the write speed, we use dd to write arbitrary data as fast as possible. It’s important to circumvent the OS’ disk cache to get realistic results (oflag). We write a 10 GB file by reading from /dev/zero:
> dd if=/dev/zero of=/var/lib/ceph/osd/ceph-10/deleteme bs=10G count=1 oflag=direct

For the second step, we start the same dd process for all 12 data disks simultaneously — every dd is put in the background to run in parallel.
> for i in `mount | grep osd | awk '{print $3}'`; do dd if=/dev/zero of=$i/deleteme bs=10G count=1 oflag=direct &; done

For determining read speed, we read the created files; again, bypassing the cache (ifloag), reading from one and then from all disks:
> time dd if=/var/lib/ceph/osd/ceph-10/deleteme of=/dev/null bs=10G count=1 iflag=direct
> for i in `mount | grep osd | awk '{print $3}'`; do dd if=$i/deleteme of=/dev/null bs=10G count=1 iflag=direct &; done

The results are shown in figure 1. As you can see, a single disk can write up to 154 MB/s and read up to 222 MB/s. If all disks are used at the same time, the write speed decreases to an average of 93 MB/s and the read speed to 142 MB/s respectively which are pretty good results.

Figure 1 — Write performance for 1 and 12 disks in parallel.

Baseline - Network

Ceph suggests that there should be two separate designated networks: a cluster and a public network. Ceph uses the cluster network for internal synchronization as well as replication while the public network is handling client requests. We use four physical links, bonded together in pairs to form one link for each of the two networks. See the configuration for a bonded interface on Ubuntu below — we use a little trick to set the VLAN specific interface name to a human readable string instead of something like bond0.105. This makes the configuration less error prone.

> cat /etc/network/interfaces
...
auto bond2
iface bond2 inet manual
bond-slaves p2p3 p2p4 # interface to bond
bond-mode 802.3ad # activate LACP
bond-miimon 100 # monitor link health
bond-xmit_hash_policy layer3+4 # use Layer 3+4 for link selection
pre-up ip link set dev bond2 mtu 9000 # set Jumbo Frames

auto vlan-ceph-clust
iface vlan-ceph-clust inet static
pre-up ip link add link bond2 name vlan-ceph-clust type vlan id 105 # Little trick
  # to set human readable interface name
pre-up ip link set dev vlan-ceph-clust mtu 9000 # Jumbo Frames
post-down ip link delete vlan-ceph-clust # unset human readable interface name
address 10.102.5.12 # IP config
netmask 255.255.255.0
network 10.102.5.0
broadcast 10.102.5.255
...

The theoretical maximum performance for the bonded network interfaces is 2 Gbit/s = 250 MB/s. iperf is an excellent tool to measure network throughput which we use for this measurement. We start an iperf server process on node01 and two iperf clients sending via two TCP streams each on node02 and node03:

[node02] > iperf -c node01.ceph-cluster -P 2
[node03] > iperf -c node01.ceph-cluster -P 2
[node01] > iperf -s -B node01.ceph-cluster
------------------------------------------------------------
Server listening on TCP port 5001
Binding to local address node01.ceph-cluster
TCP window size: 85.3 KByte (default)
------------------------------------------------------------
[ 4] local 10.102.5.11 port 5001 connected with 10.102.5.12 port 49412
[ 5] local 10.102.5.11 port 5001 connected with 10.102.5.12 port 49413
[ 6] local 10.102.5.11 port 5001 connected with 10.102.5.13 port 59947
[ 7] local 10.102.5.11 port 5001 connected with 10.102.5.13 port 59946
[ ID] Interval Transfer Bandwidth
[ 4] 0.0-10.0 sec 342 MBytes 286 Mbits/sec
[ 5] 0.0-10.0 sec 271 MBytes 227 Mbits/sec
[SUM] 0.0-10.0 sec 613 MBytes 513 Mbits/sec
[ 6] 0.0-10.0 sec 293 MBytes 246 Mbits/sec
[ 7] 0.0-10.0 sec 338 MBytes 283 Mbits/sec
[SUM] 0.0-10.0 sec 631 MBytes Mbits/sec

The results are rather disappointing as we achieve only roughly 513 Mbit/s + 529 Mbit/s or about 130 MB/s. What’s wrong here?

IEEE 802.3ad using layer 3 and 4

IEEE 802.3ad uses the TCP connection 4-tuple (Src IP, Src Port, Dst IP, Dst Port) to determine the physical link of a bonded link to send data over.¹ Yes, send. According to the standard, the sender decides which physical link to use. This means that our two senders (node02 and node03) select a sending link and start to transmit data as fast as possible. But the switch connecting the senders to the receiver (node01) does not know about that. All it sees are layer 2 frames designated for a specific MAC address to which it forwards the frames. So while the two senders fully utilize a 1 GBit/s link, the switch only forwards to the receiver via one single physical link which results in the observed throughput.²

Baseline - Network: done right

If we switch the experiment’s parameters to one sender and two receivers, we get the expected results. This time, node01 sends node02 and node03 simultaneously via two separate processes. We simply use netcat to send and pv to display the throughput.

[node02] > netcat -l -p 5001 > /dev/null
[node03] > netcat -l -p 5001 > /dev/null
[node01] > dd if=/dev/zero | pv | netcat node02.ceph-cluster 5001 &
173GB 0:25:36 [ 115MB/s]
[node01] > dd if=/dev/zero | pv | netcat node03.ceph-cluster 5001 &
173GB 0:25:36 [ 115MB/s]

Here we go. Now we see interface bonding in action — cf. figure 2.

Figure 2 — Network performance for 1 and 2 streams over a bonded network interface.

This means that the maximum transmission speed is around 230 MB/s — depending on the generated load and its processes. The maximum write speed for a single disk is around 150 MB/s and for all disks used at the same time around 90 MB/s. Reading speeds are 220 MB/s and 140 MB/s respectively.

Ceph Object Store

Ceph is a Reliable Autonomic Distributed Object Store (RADOS) that does not have a single point of failure as there is no central component, making it a perfect fit for CenterDevice’s architecture. In contrast to other distributed stores, Ceph uses an algorithm-only method to locate and store an object. This means that every client only needs to apply the CRUSH (Controlled, Scalable, Decentralized Placement of Replicated Data) algorithm to compute the corresponding object disk storage daemon (OSD) that is responsible for storing a particular object. Since different objects are stored by different OSDs, a client sending multiple objects talks to multiple nodes which allows it to make use of bonded links as described above.

Ceph has an integrated benchmark program which we use for measuring the object store performance. The corresponding command is rados bench. In general, this benchmark writes objects as fast as possible to a Ceph cluster and reads them back sequentially afterwards — see rados bench —help for details.³ Again, we proceed in two steps. First, we run only one load generator and second, we run 4 load generators on each Ceph node. It is important to note that all objects are replicated for data safety once in the system, leading to load on both the public as well as the cluster network.

[node01] > rados bench -p data 300 write --no-cleanup && rados bench -p data 300 seq # --no-cleanup leaves written data in ceph for read benchmark

We repeat this command in parallel on all four nodes. Figure 3 presents the results for both runs.

Figure 3 — Ceph read and write performance for 1 and 4 load generators.

The result for the write speed of one load generator is quite surprising. It’s almost the perfect theoretical network throughput of 245 MB/s. There are two explanation for this observation. Since all node have 128 GB RAM, there is plenty of room to buffer data before actually writing them to the disks. In this way, the network and disk IO is decoupled. In addition, the benchmark is running on all Ceph worker nodes. Since we have 4 nodes, 1/4 of the data to write is delivered locally. Consistently, write speed drops significantly when load is generated by all 4 nodes. Interestingly, the average write performance is still greater than an individual disk even though every object is replicated once which doubles the load in the cluster network. The big surprise is read speed though which remains constant and independent from the work load.

When we compare these results with our baseline, we realize that even in high load situations (4 load generators for 4 worker nodes), the write and read speed is higher than a single local disk which is quite impressive taking into account that all writes were duplicated for data safety.

Ceph Performance Conclusion

Our internally run tests consist of many more scenarios than presented in this blog post. During all our tests, Ceph did its job without any quirks. The performance remains very stable even in high load situations and independently of the amount of data stored. In our opinion, Ceph is an excellent choice to store large amounts of data outperforming our former solution. Ceph gives you a reliable, cheap, and performant alternative to commercial SANs and distributed file storage.

We also have to say that the observed performance is the result of a carefully tweaked hardware and software configuration. So while Ceph is excellent choice for distributed object and file storage, the installation and configuration requires a high amount of Unix, networking, and Ceph internals knowledge.

There’s more

Ceph offers way more than the described object storage. It allows you to introduce multiple redundancies — we are going to use three times redundancy in production — and snapshotting for versioning objects. On top of the object store, Ceph has a Amazon S3 and OpenStack Swift compatible REST Gateway (RADOSGW) and even a file system layer called CephFS. We benchmarked these layers, too, but omitted them here for brevity.

Feel free to contact us if you have questions and comments.

Footnotes

1. If frames of a single TCP stream are sent over both links, out of order reception may occur. In such a scenario, TCP would assume packet loss due to duplicate ACKs and eventually significantly reduce the sending speed. Therefore, packets of one TCP stream always travel over the same wire.↵
2. There are actually frames forwarded using the second link as the average throughput is a little bit higher than the maximum single link speed of 125 MB/s.↵
3. Even though listed in the help output, random reads are currently not implemented.↵

★ Docker Registry or How to Run your own Private Docker Image Repository

Tue, 18 Feb 2014 09:11:00 GMT

Docker allows to bundle artifacts and configurations in an image. These images run as light weight system-level virtual machines. In my previous articles, I showed how to use Docker in general and how to use networking. In this article, I will show you how to manage images in a private Docker registry — basically a git repository for images — and run a production grade registry. As in my previous articles, a fully working example is available on Github to get you started with your own private Docker registry.

Every single command in a Dockerfile yields a new Docker image with an individual id similar to a commit in git. This commit can be tagged for easy reference with a Docker Tag. In addition, tags are the means to share images on public and private repositories.

Registry

You can download the docker registry from here. The configuration of a registry is straight forward and described in the corresponding Readme. You can define different modes a registry should run called flavors, e.g. for debugging, different storage backend etc. Docker registry supports multiple storage backend. You can choose from local file system, Amazon S3, OpenStack Glance etc.

If you run a production registry with multiple workers, it is crucial to set a “secret_key” in the configuration file config/config.yml to a 64 characters long value. Otherwise, you will get very confusing errors if you run more than one worker thread.

In order to retrieve an image from a repository, run docker pull <name> where name denotes the repo_name given above. If you want to select a specifically tagged version, you can supply the tag with the -t option.

For an image from the Docker Index, run
> docker pull lukaspustina/registry-demo

and for a private registry, run
> docker pull localhost:5000/registry-demo

Demo

You can find my demo project on GitHub. You can either run it directly on a Docker compatible OS like Linux and OS X or use Vagrantfile to setup a Virtual Box — see the Readme on GitHib for details.

The demo consists of two steps. The first step builds a production-ready Docker Image containing the Docker registry and two Python images for 2.7 and 3.3 which are pushed to the registry.² For this demo, the two Python version are used as two versions of the same artifact ‘python’ to demonstrate how to use tags for versioning images of the same repository.
> make build

You can see how the docker layers are uploaded to the registry:

Pushing repository localhost:5000/python (2 tags)
Image 511136ea3c5a Image successfully pushed
Image cc7385a89304 Image successfully pushed
Image 24ba2ee5d982 Image successfully pushed
Image a49658c12a4f Image successfully pushed
Image 7adcddf9f908 Image successfully pushed
Image 818c514e00c0 Image successfully pushed
Image 480cb1b9f62c Image successfully pushed
Image 9eeddd8616b7 Image successfully pushed
Image c26adcc0bc2a Image successfully pushed
Pushing tag for rev [c26adcc0bc2a] on
  {http://localhost:5000/v1/repositories/python/tags/python-2}
Image c04e8b52daba Image successfully pushed
Image 1ebdf4e79ef1 Image successfully pushed
Pushing tag for rev [1ebdf4e79ef1] on
  {http://localhost:5000/v1/repositories/python/tags/python-3}

You can also see that tags for the two Python version are also transmitted allowing a user to pull only a specific version.

The second step pulls the Python images and run them demonstrating the whole life cycle of build, pushing, pulling, and running image with your own, private Docker registry.
> make start-registry pull run-python-2 run-python-3 stop-registry

You can see how the individual layers of the Python images are gathered and afterwards run:

docker pull localhost:5000/python
Pulling repository localhost:5000/python
1ebdf4e79ef1: Download complete
c26adcc0bc2a: Download complete
511136ea3c5a: Download complete
cc7385a89304: Download complete
24ba2ee5d982: Download complete
a49658c12a4f: Download complete
7adcddf9f908: Download complete
818c514e00c0: Download complete
480cb1b9f62c: Download complete
c04e8b52daba: Download complete
9eeddd8616b7: Download complete
...
docker run localhost:5000/python:python-2
Python version is 2.7.5+
docker run localhost:5000/python:python-3
Python version is 3.3.2+

Running a Production Registry

At CenterDevice we are running a Docker registry on our Jenkins CI server. The main command line to run the registry is
> SETTINGS_FLAVOR=prod DOCKER_REGISTRY_CONFIG=/etc/docker/config.yml gunicorn -k gevent -b localhost:5000 --max-requests 100 --graceful-timeout 3600 -t 3600 -w 8 wsgi:application

which sets the flavor and the location of the configuration file. In addition, it starts 8 worker threads and listens only on localhost. Since the current version of Docker registry has no authentication, we use ssh tunnels for this purpose. The registry instance only listens on localhost. If you want to connect to the registry, you need to create a tunnel first with
> ssh -N -L 5000:localhost:5000 user@server

This requires a valid user on our server and enforcing authentication and authorization. For the storage backend we use S3.

The Dockerfile in the GitHub demo project is almost the same as the one we use on our Jenkins. Please feel free adapt it to your needs. The main difference is that the demo uses local file storage, but the config.yml template file is already prepared for S3. See the Readme for details. If you’re feeling lazy, you also find this Docker image on Docker Index.

There’s more

At CenterDevice, we like to use private Docker registries because they allow us to safely share Docker images in our organization. We maintain all our backend service as well as our app images in a private registry. In this way, a developer only needs to pull changed images to update his development environment. In the future, we plan to use these images for production environments, too.

Docker is evolving very quickly, with a minor version update planed each month. So stay tuned for more articles about how we use Docker at CenterDevice (German readers can read more about it here).

Footnotes

1. You can run my shared registry directly: > docker run --name registry -d -p 5000:5000 -v <absolute local path>:/docker-registry-storage lukaspustina/registry-demo.↵
2. Please be patient as the build process takes quite some time.↵

★ Docker Networking Made Simple or 3 Ways to Connect LXC Containers

Sun, 26 Jan 2014 19:37:00 GMT

In my previous article, I introduced Docker as a lightweight alternative to hypervisor-based virtualization. The article described the basic usage of Docker. Today, we dig a bit deeper and cover advanced topics regarding Docker networking and how to connect containers with each other as well as the outside world. Finally, I show how to fully integrate containers in your real network. As an example, I use a web service that processes birthdays of famous physicists¹ served by three concurrently running Python web servers backed by a MongoDB. The example is freely available on GitHub as a fully working Vagrant box.

In general, there are three ways to configure networking for Docker containers that complement each other: Link, Port, and Pipework.

Link - Automatically Connect Services

Docker links automatically propagate exposed ports of one container as shell variables to another container. In this way, the second container can dynamically adjust network settings upon startup without the need to modify an image nor configurations.

In order to start a container, run
> docker run -name <name> <image id | image repository:tag>
The name denotes a symbolic name the running container instance should be identified by. For example, the MongoDB container
> docker run -d -name mongodb docker-network-demo/mongodb:latest

Each container gets a dynamic IP address automatically assigned upon start. You can query it by name

> docker inspect <name> | grep IPAddress | awk '{print $2}' | tr -d '",\n’
172.17.0.2

In the Dockerfile, port 27017 is exposed for the MongoDB’s container image making it accessible from outside the container.²

VOLUME ["/data/mongodb"]
EXPOSE 27017
ENTRYPOINT ["/usr/bin/mongod"]
CMD ["--port", "27017", "--dbpath", "/data/mongodb", "--smallfiles"]

By using the additional parameter -link <name:alias> to the run command, a link is established to the container <name> and called <alias>. For a web server from our example:
> docker run -d -name webserver1 -link mongodb:mongo docker-network-demo/webserver:latest

This link connects the web server to the MongoDB and automatically creates environment variables in the web server container passing IP address and exposed port from the MongoDB to the web server container. The environment variables are prefix with the alias name capitalized and the exposed port number. To show these variables run

> vagrant@docker-network-demo:/vagrant$ docker run -t -i -link mongodb:mongo
   docker-network-demo/webserver env
HOME=/
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME=04a4ee4470e1
TERM=xterm
MONGO_PORT=tcp://172.17.0.2:27017
MONGO_PORT_27017_TCP=tcp://172.17.0.2:27017
MONGO_PORT_27017_TCP_ADDR=172.17.0.2
MONGO_PORT_27017_TCP_PORT=27017
MONGO_PORT_27017_TCP_PROTO=tcp
MONGO_NAME=/insane_albattani/mongo
container=lxc

As you can see, $MONGO_PORT_27017_TCP_ADDR and $MONGO_PORT_27017_TCP_PORT contain the necessary information to connect to the MongoDB instance.

These environment variables can also be used in other Dockerfiles like our the web server:

ADD webserver.py /opt/webserver/webserver.py
EXPOSE 8080
CMD /opt/webserver/webserver.py 8080 $MONGO_PORT_27017_TCP_ADDR $MONGO_PORT_27017_TCP_PORT

In this way, the MongoDB connection parameters are automatically passed to the Python script webserver.py without any external dependency management. It is import to note here that there are several syntax forms of the CMD command and only this one allows us to use the environment variables; cf. [1] and [2].

As result, let’s start our full example:

> docker run -d -name mongodb docker-network-demo/mongodb:latest
> docker run -d -name webserver1 -link mongodb:mongo docker-network-demo/webserver:latest
> docker run -d -name webserver2 -link mongodb:mongo docker-network-demo/webserver:latest
> docker run -d -name webserver3 -link mongodb:mongo docker-network-demo/webserver:latest

For a quick demo, we define a shell function to retrieve a container’s IP address by name:

function getWebserverIP() {
  docker inspect $1 | grep IPAddress | awk '{print $2}' | tr -d '",\n'
}

Now we can post birthdays to the three web servers which are persisted to MongoDB:

> curl -X POST -H "Content-Type: application/json" -d '{"name":"James Clerk Maxwell",
  "birthday":"13.06.1831"}' http://$(getWebserverIP webserver1):8080
> curl -X POST -H "Content-Type: application/json" -d '{"name":"Albert Einstein",
  "birthday":"14.03.1879"}' http://$(getWebserverIP webserver2):8080
> curl -X POST -H "Content-Type: application/json" -d '{"name":"Werner Heisenberg",
  "birthday":"05.12.1901”}' http://$(getWebserverIP webserver3):8080

And retrieve these birthdays

> curl http://$(getWebserverIP webserver1)
name = James Clerk Maxwell, birthday = 13.06.1831
name = Albert Einstein, birthday = 14.03.1879
name = Werner Heisenberg, birthday = 05.12.1901

As you can see, no parameterization is necessary to connect the web servers to the MongoDB as docker run -link automatically passes the correct network connection information.

Port - Expose Services to Host Port

Docker links interconnect containers. But how do we connect containers to the outside world? There are two different approaches here that are complementary. Docker port and pipework.

The docker run -port parameter serves another purpose to enable networking with Docker containers. It comes in three syntax flavors
-p=[]: Publish a container’s port to the host (format: ip:hostPort:containerPort | ip::containerPort | hostPort:containerPort)

and specifies on which host IP address and port an exposed container port should be provided. In case the host IP address or port are omitted, all host interfaces or the same port as exposed are used, respectively. In this way, a connection to the host port is forwarded to the container.

In our example, we expose the web server container’s port to the same port of the host:
> docker run -d -name webserver -link mongodb:mongo -p 8080:8080 docker-network-demo/webserver:latest

In order to check to which IP addresses and port an exposed port — so called private port — is mapped to, run

> docker port webserver 8080
0.0.0.0:8080

In this case, the port is exposed to the same host port as desired and is listening on all host interfaces.

Now you can access the example web service by the host IP address (see Vagrantfile on GitHub):
> curl -X POST -H "Content-Type: application/json" -d '{"name":"Albert Einstein", "birthday":"14.03.1879"}' http://10.2.0.10:8080
Pipework - More Networks for your Containers

Docker creates a special Linux bridge called docker0 on startup. All containers are automatically connected to this bridge and the IP subnet for all containers is randomly set by Docker. Currently, it is not possible to directly influence the particular IP address of a Docker container. Luckily, there is a shell script pipework which you can use to add another interface to a container with a specified IP address. I contributed to the script, so as to allow adding arbitrary numbers of interfaces. For example
> sudo ./pipework docker0 -i eth1 $(docker ps -q -l) 10.2.0.11/16

adds the interface eth1 with IP address 10.2.0.11 to the last started container.³

Integrate Docker Containers into your Host Network

In addition to specifying additional interfaces, you can even put all containers on the same network as the host with some Linux networking tricks.
Let’s suppose for the following that your host is connected to the local network by interface eth1 with IP address 10.2.0.10/16 as it is configured in the Vagrantfile on GitHub.

First, we need to place the Docker bridge interface into the same network as our host for which the -bip parameter of the Docker daemon is intended. On Ubunutu, you can change this parameter by modifying the file /etc/default/docker:
DOCKER_OPTS=-bip=10.2.0.10/16

Second, since this leads to two interfaces on the same IP network on your host (docker0 as well as the eth1), the TCP/IP stack does not know which hosts of that network can be reached via which interface. Therefore, we need to help the stack with its routing decisions. The easiest way to connected these two network segments is to make use of the Docker bridge which is already configured. In this way, we don’t need additional routing information but solely rely on the network level 2 mechanism.

First, we unbind the network address of eth1 and then, we attach eth1 as another interface to the docker0 bridge:

> ip addr del 10.2.0.10/16 dev eth1
> ip link set eth1 master docker0
> ifconfig docker0
docker0 Link encap:Ethernet HWaddr 08:00:27:09:bc:ad
inet addr:10.2.0.10 Bcast:0.0.0.0 Mask:255.255.0.0
inet6 addr: fe80::b023:75ff:fead:c70e/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:59816 errors:0 dropped:0 overruns:0 frame:0
TX packets:126844 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:2491020 (2.4 MB) TX bytes:112308729 (112.3 MB)

> ifconfig eth1
eth1 Link encap:Ethernet HWaddr 08:00:27:09:bc:ad
inet6 addr: fe80::a00:27ff:fe09:bcad/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:646 errors:0 dropped:0 overruns:0 frame:0
TX packets:159 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:111487 (111.4 KB) TX bytes:11220 (11.2 KB)

In the Vagrant box example on GitHub, I added these two commands to /etc/rc.local so that they are executed automatically after each boot.

When using this mode of networking, it is important to avoid IP address conflicts, because Docker still randomly assigns IP address to started containers. But now these IP addresses are coming from a real IP network. Therefore, I usually complement this setup with pipework to set static IP addresses for my container which I know will not create an IP address conflict. Marek Goldman suggests other ways of circumvention that work as well.

There’s more

Docker offers much more functionality when dealing with Linux Containers. For example, you can use a image registry which is like a git for Docker images, and you can run publicly or privately in your organization. With these registries you can push to and pull from Docker images which are versioned and may be tagged.

I will blog about these topics in the future. So stay tuned and feel free to contact me, if you have questions or comments.

Footnotes

1. You can actually send arbitrary JSON documents which will be correctly processed.↵
2. By default, only exposed ports of a container are accessible.↵
3. Protip: Save docker ps -q -l as an alias; it saves you time when working with Docker.↵

★ Leichtgewichtige virtuelle Maschinen mit Docker oder wie man 100 VMs laufen lässt

Mon, 06 Jan 2014 10:30:00 GMT

Virtuelle Maschinen haben viele Vorteile. Sie nutzen die Hardware besser aus, können leicht gesichert sowie ausgetauscht werden und isolieren einzelne Dienste voneinander. Sie haben jedoch auch Nachteile. Images sind sperrig und virtuelle Maschinen verbrauchen recht viele Ressourcen, da sie Hardware emulieren und ein gesamtes Betriebssystem laufen lassen. Mit Linux Containern gibt es eine leichtgewichtige Alternative. In diesem Artikel stelle ich Docker vor, ein Tool, das die praktische Anwendung von Linux Containern erleichtert. Dazu zeige ich anhand eines Beispiels, wie man 100 virtuelle Maschinen auf seinem System laufen lassen kann. Das Beispiel liegt dazu bei Github, so dass man es selbst ausprobieren kann.

Was ist Docker?

Linux Container (LXC) sind seit Version 2.6.24 Bestandteil von Linux and erlauben sogenannte System-Level Virtualisierungen. Sie setzen auf Linux cgroup und name spaces, die Prozesse voneinander isolieren. Sie laufen daher scheinbar auf ihrem eigenen System. Docker baut auf Linux Containern auf und besteht aus drei Teilen: Docker Daemon, Docker Images, the Docker Repositorys.

Docker Daemon läuft als root und verwaltet alle laufenden Container. So wie Virtuelle Maschinen auf Images basieren, basieren Docker Container auf Docker Images. Diese Images sind winzig verglichen mit virtuellen Maschinen Images und sind dank AUFS ”stapelbar”, so dass nur Änderungen gespeichert werden — siehe unten. Mit Hilfe von privaten und öffentlichen Docker Repositorys können Docker Images mit anderen geteilt und wie Source Code versioniert werden.

Ein Beispiel: 100 virtuelle Maschinen auf einem System

Um in die Nutzung von Docker einzuführen, zeige ich im Folgenden anhand eines Beispiels, wie Docker funktioniert. In diesem Beispiel werden 100 Docker Container jeweils mit eigener IP-Adresse gestartet und beantworten Webanfragen auf Port 8080. Als Webserver dient ein kleines Python Script. Das vollständige Beispiel ist bei Github verfügbar, so dass man es selbst ausprobieren kann.

Vom Dockerfile zum Docker Image

Ein Dockerfile beschreibt wie ein Docker Image erstellt werden soll. Für das Beispiel nutze ich zwei Dockerfiles, eins für die Python-Laufzeitumgebung und ein zweites für den eigentlichen Python Webserver. Listings 1 und 2 zeigen die beiden Dockerfiles.

FROM ubuntu:quantal
MAINTAINER Lukas Pustina <lukas.pustina@centerdevice.com>
RUN apt-get install -y python
Listing 1

Das FROM Kommando gibt das Ausgangsimage für das neue Image an. Hier wird ein öffentliches Ubuntu Image benutzt. Images werden zuerst lokal und dann im öffentlichen Docker Repository nachgeschlagen. Das RUN Kommando spezifiziert Shell-Kommandos, die während des Builds ausgeführt werden sollen. Hier wird Python installiert.

FROM docker-demo/python
MAINTAINER Lukas Pustina <lukas.pustina@centerdevice.com>
ADD webserver.py /opt/webserver/webserver.py
ADD run.sh /opt/webserver/run.sh
EXPOSE 8080
VOLUME ["/logs”]
Listing 2

Das zweite Docker Image leitet vom ersten Image mit der Python Laufzeitumgebung ab und fügt die beiden Dateien webserver.py and run.sh hinzu. Im Allgemeinen dürfen Docker Container nicht mit der Außenwelt kommunizieren — eine Deny All Regel. Falls Kommunikation möglich sein soll, muss diese explizit mit dem EXPOSE Kommando erlaubt werden. Erst dann wird der Port 8080 nach außen weitergeleitet. Das VOLUME Kommando gibt einen Mount Point an, an den Dateisysteme aus dem Host gebunden werden können. Auf diese Weise können global wiederverwendbare und teilbare Mount Points eingehängt werden.

Images bauen: docker build

Docker Images werden aus Dockerfiles erzeugt. Dabei erzeugt jedes Kommando eines Dockerfiles ein neues Image, das wie ein git Commit über eine eindeutige ID referenziert werden kann. Zum Beispiel erzeugt folgender Befehl das Image für die Python-Laufzeitumgebung

> docker build -rm -t docker-demo/python python

im Verzeichnis python, löscht dann alle Teil-Images (-rm) und taggt das Ergebnis-Image mit ”docker-demo/python”.

> docker images

zeigt all zur Zeit existierenden Images an. In unserem Beispiel (Die Größe bezeichnet die virtuelle Größe — siehe unten):

docker-demo/python      latest   ef489f0186e1        Less than a second ago   210.7 MB
docker-demo/webserver   latest   b898a85622e4        Less than a second ago   210.7 MB
ubuntu                  quantal  b750fe79269d        9 months ago             175.3 MB

> docker images -tree

zeigt die Vererbungshierarchie der Images sowie ihre physikalische und virtuelle Größe an:

└─27cf78414709 Size: 175.3 MB (virtual 175.3 MB)
  └─b750fe79269d Size: 77 B (virtual 175.3 MB) Tags: ubuntu:quantal
    └─7c1926658b21 Size: 0 B (virtual 175.3 MB)
      └─ef489f0186e1 Size: 35.43 MB (virtual 210.7 MB) Tags: docker-demo/python:latest
        └─90807ce05b64 Size: 0 B (virtual 210.7 MB)
          └─d3822b811f4c Size: 0 B (virtual 210.7 MB)
            └─380871b22bde Size: 1.454 kB (virtual 210.7 MB)
              └─8f5a9cde5ae2 Size: 161 B (virtual 210.7 MB)
                └─b898a85622e4 Size: 0 B (virtual 210.7 MB) Tags: docker-demo/webserver:latest

Die physikalische Größe ändert sich also nur, wenn Dateien hinzugefügt werden. Das Tagging ändert die Größe nicht. Beachtenswert ist, dass ein Docker Image mit einem Python Webserver nur ca. 180 MB groß ist.

Änderungen machen

Wenn man eine Änderung an einem Image durchführt, so werden nur die entsprechenden Container geändert. In diesem Beispiel wird der Webserver Container ein zweites Mal gebaut und docker images -tree erneut aufgerufen:

└─27cf78414709 Size: 175.3 MB (virtual 175.3 MB)
  └─b750fe79269d Size: 77 B (virtual 175.3 MB) Tags: ubuntu:quantal
    └─7c1926658b21 Size: 0 B (virtual 175.3 MB)
      └─ef489f0186e1 Size: 35.43 MB (virtual 210.7 MB) Tags: docker-demo/python:latest
        └─90807ce05b64 Size: 0 B (virtual 210.7 MB)
          |─0e153dd3c547 Size: 0 B (virtual 210.7 MB)
          | └─922d6e34d2d5 Size: 1.454 kB (virtual 210.7 MB)
          |   └─4bfc3d0fb5b2 Size: 161 B (virtual 210.7 MB)
          |     └─abac38e20f27 Size: 0 B (virtual 210.7 MB) Tags: docker-demo/webserver:latest
          └─d3822b811f4c Size: 0 B (virtual 210.7 MB)
            └─380871b22bde Size: 1.454 kB (virtual 210.7 MB)
              └─8f5a9cde5ae2 Size: 161 B (virtual 210.7 MB)
                └─b898a85622e4 Size: 0 B (virtual 210.7 MB)

Die Basis-Images bleiben gleich und nur die Kommandos des zweiten Dockerfiles werden erneut ausgeführt. Sie ändern nur wenige Bytes; nicht schlecht für ein Image einer virtuellen Maschine.

Container starten: docker run

Um Docker Container eines bestimmten Images zu starten ruft man docker run auf:

> docker run -d -cidfile=webserver.cid -name webserver -v `pwd`/logs:/logs docker-demo/webserver:latest /opt/webserver/run.sh

In unserem Beispiel wird das Docker Image das zuletzt mit "docker-demo/webserver” getagt worden ist gestartet. Das heißt, dass Image abac38e20f27 an Stelle von b898a85622e4 genutzt wird. Die Container-ID wird in die Datei webserver.cid (-cidfile) geschrieben, der Container “webserver” benannt (-name), und das lokale Verzeichnis logs wird nach /logs im Container gemappt. (-v; siehe Dockerfile oben). Der Prozess, der im Container ausgeführt werden soll, ist /opt/webserver/run.sh, welcher im zweiten Dockerfile in das Image kopiert worden ist. Man kann diesen Befehl auch mehrmals ausführen:

> for i in `seq 1 10`; do docker run -d -cidfile=webserver-$i.cid -name webserver-$i -v `pwd`/logs:/logs docker-demo/webserver:latest /opt/webserver/run.sh /logs; done

Das vollständige Beispiel auf Github startet ohne Probleme 100 Maschinen in einer Vagrant Box.

Anzeigen der laufenden Container: docker ps

Ähnlich wie ps zeigt docker ps die laufenden Container:

CONTAINER ID  IMAGE                          COMMAND                PORTS     NAMES
63120c069662  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-10
5af293d56a0b  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-9
a4a44f159658  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-8
40b35ff10aa2  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-7
6e9127f8a113  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-6
4623905191d2  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-5
e57def12fe25  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-4
c352eccb21de  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-3
f65e43115864  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-2
111c936c2763  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-1

Wie man sehen laufen 10 Container mit den Namen *webserver-** und lauschen auf Port 8080.

Informationen anzeigen lassen: docker inspect

docker inspect gibt zusätzliche Informationen über Container als JSON Dokument zurück. Dies beinhaltet u.a. den hostname, das Verzeichnis des Images oder auch die IP-Adresse, nach der im Folgenden gegrept wird:

> docker ps -q | xargs docker inspect | grep IPAddress | cut -d ‘"’ -f 4

172.17.0.12
172.17.0.11
172.17.0.10
172.17.0.9
172.17.0.8
172.17.0.7
172.17.0.6
172.17.0.5
172.17.0.4
172.17.0.3

Jeder Container hat also ein eigenes Netzwerkinterface mit eigener IP-Adresse. Zusammen bilden sie ein eigenes Netzwerk von isolierten, System-Level virtuellen Maschinen.

Ressourcenverbrauch

"ps aux | grep 'lxc-start\|python’” zeigt die verbrauchten Ressourcen der 10 Linux Container an. Man kann sehen, dass pro Container ca. 1,3 MB und pro Python Instanz ca. 7 MB RAM verbraucht werden — ganz schön beeindruckend im Vergleich zu klassischen virtuellen Maschinen.

  PID %CPU %MEM   RSS COMMAND
12197  0.0  0.2  1316 lxc-start
12249  0.0  0.2  1320 lxc-start
12291  0.0  1.3  6968 /usr/bin/python /opt/webserver/webserver.py
12296  0.0  0.2  1320 lxc-start
12346  0.0  1.3  6960 /usr/bin/python /opt/webserver/webserver.py
12348  0.0  0.2  1316 lxc-start
12399  0.0  1.3  6964 /usr/bin/python /opt/webserver/webserver.py
12400  0.0  0.2  1316 lxc-start
12450  0.0  0.2  1316 lxc-start
12496  0.0  1.3  6964 /usr/bin/python /opt/webserver/webserver.py
12497  0.0  0.2  1316 lxc-start
12546  0.0  0.2  1316 lxc-start
12594  0.0  0.2  1320 lxc-start
12648  0.0  1.3  6968 /usr/bin/python /opt/webserver/webserver.py
12649  0.0  0.2  1316 lxc-start
12700  0.0  1.3  6968 /usr/bin/python /opt/webserver/webserver.py
12701  0.0  1.3  6968 /usr/bin/python /opt/webserver/webserver.py
12707  0.0  1.3  6960 /usr/bin/python /opt/webserver/webserver.py
12711  0.0  1.3  6968 /usr/bin/python /opt/webserver/webserver.py
12712  0.0  1.3  6964 /usr/bin/python /opt/webserver/webserver.py

docker stop, kill, remove

Um Container zu stoppen, genügt es, dem ausgeführten Prozess ein SIGTEM oder SIGKILL zu schicken. docker stop versucht zunächst ein SIGTERM zu schicken. Bleibt dies bis zu einem Timeout ohne Reaktion, wird ein SIGKILL geschickt. docker kill sendet sofort ein SIGKILL. Wie bei klassischen virtuellen Maschinen bleiben die Images nach Beenden der VM bestehen. docker rm löscht Container.

Es gibt mehr

Linux Container bieten durch Docker noch viele weitere Möglichkeiten, als ich hier beschrieben habe. So ist es möglich, Volumes zwischen Containern zu teilen. Container können auch multi-homed sein und mehrere Netzwerkinterfaces konfigurieren. Private Repositorys können leicht aufgesetzt werden und ermöglichen die Verwaltung eigener Images. Zusätzlich können weitere der Kommandozeilen-Argumente von Docker in Dockerfiles eingetragen werden.

Docker bei CenterDevice

Bei CenterDevice haben wir unsere Entwicklungsumgebung auf eine Vagrant-basierte Virtual Box migriert, die Docker Images für all unsere Backenddienste wie MongoDB, RabbitMQ und Tomcat nutzen. Auf diese Weise können Entwickler ihre Entwicklungsumgebung leicht aufsetzen sowie die Dienste isoliert und wie auf Produktion laufen lassen, ohne die Ressourcen ihres Entwicklungssystem zu überlasten.

In folgenden Artikeln werde ich zeigen, wie das Erzeugen von Docker Images in die Continuous Integration Pipeline eingebaut werden kann. So können erfolgreiche Builds automatisch in Docker Images überführt werden, die dann in der Entwicklung, zum Testen und sogar in der Produktion eingesetzt werden können.

Ich werde über dieses Thema auch in Zukunft bloggen. Also bleibt dran und meldet Euch bei mir, falls Ihr Fragen oder Anregungen habt.

★ Lightweight Virtual Machines Made Simple with Docker or How to Run 100 Virtual Machines

Mon, 06 Jan 2014 10:30:00 GMT

Running virtual machines has many benefits. They utilize your hardware much better, are easy to backup and exchange, and isolate services from each other. But running virtual machines also has downsides. Virtual machine images are clunky. Also and more importantly, virtual machines require a fair amount of resources as they emulate hardware and run a full stack operating system. With Linux Containers there exists a lightweight alternative to full blown virtual machines while retaining their benefits. In this article, I present Docker, a tool that eases the practical application of Linux Containers with a fully working example available on Github to get you started with Docker yourself.

What is Docker?

Linux Container (LXC) has been part of Linux since version 2.6.24 and provides system-level virtualization. It uses Linux cgroups and name spaces to isolate processes from each other so they appear to run on their own system. Docker builds upon LXC and consists of three parts: Docker Daemon, Docker Images, the Docker Repositories which together make Linux Container easy and fun to use.

Docker Daemon runs as root and orchestrates all running containers. Just as virtual machines are based on images, Docker Containers are based on Docker images. These images are tiny compared to virtual machine images and are stackable thanks to AUFS storing only changes — see below. Docker Images can be exchanged with others and versioned like source code in private or public Docker Repositories.

Let me give you an example: 100 Virtual Machines on your System

As an introduction on how to use Docker yourself, I walk you through an example to show you how Docker works. In our example, 100 Docker Containers run each with an individual IP address serving web requests by a simple Python web server on port 8080. The full code for this example is available from Github so you can make your first steps with Docker right with me.

From Dockerfile to Docker Image

A Dockerfile describes how to build a Docker Image. For this example, I use two Dockerfiles, one for the Python runtime and another one for the Python script implementing the web server. Listings 1 and 2 show the corresponding files.

FROM ubuntu:quantal
MAINTAINER Lukas Pustina <lukas.pustina@centerdevice.com>
RUN apt-get install -y python
Listing 1

The FROM command defines the base image from which we start. In this example, I use a public Ubuntu image. The images are looked up locally as well as in the publicly available Docker repository. The RUN command specifies which commands to run during the build process. Here, only Python is added to the base image.

FROM docker-demo/python
MAINTAINER Lukas Pustina <lukas.pustina@centerdevice.com>
ADD webserver.py /opt/webserver/webserver.py
ADD run.sh /opt/webserver/run.sh
EXPOSE 8080
VOLUME ["/logs”]
Listing 2

The second Docker Image derives from the Python runtime, and adds the two files webserver.py and run.sh for running the web server. Generally, all Docker Containers run isolated from the world with no communication allowed — deny all policy. If there should be communication to the outside world, this must be explicitly defined through the EXPOSE command. In this example, port 8080 is exposed. The VOLUME commands specifies a mount point to which we can bind filesystems from the host operating system or other containers. This allows us to attach globally reusable and shareable mount point.

Building Images: docker build

From these Dockerfiles, Docker Images are build with each Dockerfile command generating a new Docker Image which can be individually accessed by its id — a git commit-like fingerprint. For our example we build the python runtime container

> docker build -rm -t docker-demo/python python

in directory “python”, remove all intermediate images (-rm) and tag the final results with "docker-demo/python”.

> docker images

shows all currently existing images. In our examples this is (The size denotes the virtual size — see below):

docker-demo/python      latest   ef489f0186e1        Less than a second ago   210.7 MB
docker-demo/webserver   latest   b898a85622e4        Less than a second ago   210.7 MB
ubuntu                  quantal  b750fe79269d        9 months ago             175.3 MB

> docker images -tree

shows the hierarchal inheritance and the physical as well as virtual size of the images:

└─27cf78414709 Size: 175.3 MB (virtual 175.3 MB)
  └─b750fe79269d Size: 77 B (virtual 175.3 MB) Tags: ubuntu:quantal
    └─7c1926658b21 Size: 0 B (virtual 175.3 MB)
      └─ef489f0186e1 Size: 35.43 MB (virtual 210.7 MB) Tags: docker-demo/python:latest
        └─90807ce05b64 Size: 0 B (virtual 210.7 MB)
          └─d3822b811f4c Size: 0 B (virtual 210.7 MB)
            └─380871b22bde Size: 1.454 kB (virtual 210.7 MB)
              └─8f5a9cde5ae2 Size: 161 B (virtual 210.7 MB)
                └─b898a85622e4 Size: 0 B (virtual 210.7 MB) Tags: docker-demo/webserver:latest

As you can see, the physical size changed only by the size of files added. Tagging does not increase the size. Interestingly, a Docker Image running a python web server is only around 180 MB in size.

Making Changes

If a change to one image and thus a rebuild is necessary, only the corresponding containers change. In this example, the web server container has been changed and docker images -tree rerun:

└─27cf78414709 Size: 175.3 MB (virtual 175.3 MB)
  └─b750fe79269d Size: 77 B (virtual 175.3 MB) Tags: ubuntu:quantal
    └─7c1926658b21 Size: 0 B (virtual 175.3 MB)
      └─ef489f0186e1 Size: 35.43 MB (virtual 210.7 MB) Tags: docker-demo/python:latest
        └─90807ce05b64 Size: 0 B (virtual 210.7 MB)
          |─0e153dd3c547 Size: 0 B (virtual 210.7 MB)
          | └─922d6e34d2d5 Size: 1.454 kB (virtual 210.7 MB)
          |   └─4bfc3d0fb5b2 Size: 161 B (virtual 210.7 MB)
          |     └─abac38e20f27 Size: 0 B (virtual 210.7 MB) Tags: docker-demo/webserver:latest
          └─d3822b811f4c Size: 0 B (virtual 210.7 MB)
            └─380871b22bde Size: 1.454 kB (virtual 210.7 MB)
              └─8f5a9cde5ae2 Size: 161 B (virtual 210.7 MB)
                └─b898a85622e4 Size: 0 B (virtual 210.7 MB)

As you can see, the base images stay the same and only the changes from the web server Dockerfile are reapplied changing only a few Bytes. Not bad for virtual machine images.

Running Containers: docker run

To start a Docker Container and run it based on a Docker Image, you use docker run:

> docker run -d -cidfile=webserver.cid -name webserver -v `pwd`/logs:/logs docker-demo/webserver:latest /opt/webserver/run.sh

In our example, the Docker’s most recently image tagged "docker-demo/webserver” is run. This means image abac38e20f27 is used instead of b898a85622e4. The container id is written to the file webserver.cid (-cidfile), named “webserver” (-name), the host local directory logs is mapped to the container directory /logs (-v; see Dockerfile above). The process to execute inside the container is /opt/webserver/run.sh which was copied into the image by the second Dockerfile.

You can also run several containers:

> for i in `seq 1 10`; do
docker run -d -cidfile=webserver-$i.cid -name webserver-$i -v `pwd`/logs:/logs docker-demo/webserver:latest /opt/webserver/run.sh /logs;
done

The full examples on Github runs 100 machines with ease in a Vagrant Box.

Showing Running Containers: docker ps

Similar to ps, docker ps shows the running containers:

CONTAINER ID  IMAGE                          COMMAND                PORTS     NAMES
63120c069662  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-10
5af293d56a0b  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-9
a4a44f159658  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-8
40b35ff10aa2  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-7
6e9127f8a113  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-6
4623905191d2  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-5
e57def12fe25  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-4
c352eccb21de  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-3
f65e43115864  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-2
111c936c2763  docker-demo/webserver:latest   /opt/webserver/run.s   8080/tcp  webserver-1

As you can see, there are 10 containers running with the names *webserver-** and TCP port 8080 exposed.

Getting additional Information: docker inspect

docker inspect gives additional information as a JONS document for a container id. This includes the hostname, host directory the images resides, ip addresses and more. To show the IP addresses of the above started containers, we grep for IPAddress:

> docker ps -q | xargs docker inspect | grep IPAddress | cut -d ‘"’ -f 4

172.17.0.12
172.17.0.11
172.17.0.10
172.17.0.9
172.17.0.8
172.17.0.7
172.17.0.6
172.17.0.5
172.17.0.4
172.17.0.3

As you can see, each container runs with a different network interface and IP address forming a network of isolated system-level virtual machines.

Resource Usage

Running "ps aux | grep 'lxc-start\|python’” to inspect the resources used by these 10 Linux Containers, you see that for each machine the container process takes around 1.3 MB; the Python instance takes around 7 MB. That is less than 8.5 MB in total per virtual machine - quite an impressive figure as compared to real virtual machines.

  PID %CPU %MEM   RSS COMMAND
12197  0.0  0.2  1316 lxc-start
12249  0.0  0.2  1320 lxc-start
12291  0.0  1.3  6968 /usr/bin/python /opt/webserver/webserver.py
12296  0.0  0.2  1320 lxc-start
12346  0.0  1.3  6960 /usr/bin/python /opt/webserver/webserver.py
12348  0.0  0.2  1316 lxc-start
12399  0.0  1.3  6964 /usr/bin/python /opt/webserver/webserver.py
12400  0.0  0.2  1316 lxc-start
12450  0.0  0.2  1316 lxc-start
12496  0.0  1.3  6964 /usr/bin/python /opt/webserver/webserver.py
12497  0.0  0.2  1316 lxc-start
12546  0.0  0.2  1316 lxc-start
12594  0.0  0.2  1320 lxc-start
12648  0.0  1.3  6968 /usr/bin/python /opt/webserver/webserver.py
12649  0.0  0.2  1316 lxc-start
12700  0.0  1.3  6968 /usr/bin/python /opt/webserver/webserver.py
12701  0.0  1.3  6968 /usr/bin/python /opt/webserver/webserver.py
12707  0.0  1.3  6960 /usr/bin/python /opt/webserver/webserver.py
12711  0.0  1.3  6968 /usr/bin/python /opt/webserver/webserver.py
12712  0.0  1.3  6964 /usr/bin/python /opt/webserver/webserver.py

docker stop, kill, remove

In order to stop a container, it is sufficient to stop the process that the containers executes by sending SIGTERM or SIGKILL. docker stop tries to send SIGTERM first and after a timeout SIGKILL. docker kill sends SIGKILL immediately.

Like in stopped virtual machines, stopped Linux Containers still exist. To remove them, docker rm <container id> is used.

There’s more

Linux Containers offer much more functionality through Docker than I described. It is possible to share volumes between containers. Containers may be multi-homed using multiple network interfaces and networks freely configured. Private repositories can be easily set up and allow you to maintain your own set of Docker Images. Further, many command line arguments to “docker” can be moved statically to Dockerfiles.

Docker at CenterDevice

At CenterDevice we migrated our development environment on a Vagrant based Virtual Box that uses Docker Images for all backend services like MongoDB, RabbitMQ or Tomcat. In this way, each developer can easily set up a working environment, run services isolated and distributed like on production, but without exceeding resources of their development machine.

In the future, we plan to move the creation of Docker Images into our Continuous Integration pipeline. That way, a successful build generates Docker Images for development, testing, and even production.

I will blog about these topics in the future. So stay tuned and feel free to contact me, if you have questions or comments.

★ Never Change a Running System is wrong

Wed, 18 Dec 2013 10:00:00 GMT

In German, we like to make up our own English words and expressions. For example, German IT-experts have invented the saying: “Never change a running system”. What they mean by that is: “If it ain’t broken, don’t fix it”. But is that really true? I don’t think so.

If it ain’t broke, don’t fix it

Why? Because just like cars, IT systems need regular service and maintenance in order to run smoothly over a long period of time. In my article "Your Hardware will Fail – Just not the Way You Expect”, I described findings from Google researchers about hardware failures. One of the findings is that hardware components usually either fail right from the start or at the end of their life. This is describes best by the so called bathtub curve. As you can see in the figure the two curves “Infant Mortality Failure” (red) and “Wear Out Failures” (yellow) together form a bathtub curve.

Bathtub Curve - taken from Wikipedia http://en.wikipedia.org/wiki/File:Bathtub_curve.svg

Applied to IT systems this means: The older a system gets, the more likely its failure becomes. In addition to that you have to take into account that over time hardware spare parts might become scarce and vendor support for software might run out.

Always upgrade a system to keep it running

So instead of relying on your battle-proven system running for years without incident and change, you should regularly patch and update. Of course this bares risks and it is definitely not the most pleasant task. But you can mitigate the risks of updates by e.g., automatization with, e.g., Puppet, by running update test in virtualized environments, and by developing a patch management plan.

In the end, steady maintenance is much less of a hassle than standing next to your broke car on the highway not knowing if you will ever get it to work again.

★ Your Hardware will Fail - Just not the Way You Expect

Wed, 13 Nov 2013 08:00:00 GMT

Why do people decide to move their services into the cloud? For one thing they wish to store large amounts of data. But they also wish for response times and reliability that classical sever installation cannot offer. Therefore, clusters of commodity server nodes are built that deliver services as a distributed system. In such a distributed system, failures of nodes are immanent and it is important to understand the mechanics of hardware failures to successfully prepare such events. In this blog article, I present four surprising facts that shed new light on common believes about RAM and hard disk failures.

These facts are based on the two Google research papers "Failure Trends in a Large Disk Drive Population” [1] and "DRAM Errors in the Wild: A Large-Scale Field Study” [2] which cover data collected over hundreds of thousand nodes throughout Google’s data centers.

1. Lower Temperatures Lead to Higher Availably

****Having managed servers for almost 20 years, I have always been told that it is crucial for servers to be appropriately cooled in order to allow for 24/7 operation. Interestingly, Google researches concluded that temperatures impacts the reliability of neither RAM modules nor disk drives as expected.

In particular, the authors of [2] analyzed the correlation of disk drive temperatures and the “annualized failure rate” (AFR), the rate at which a disk fails per year — cf. figure 1.

Figure 1 - cf. [1]

Surprisingly, there is a clear trend that contradicts the common believe that higher temperatures lead to lower AFR until a temperature of 40°C is reached. It seems hard disks prefer a cosy, warm environment.

Similar results have been found for RAM which show that RAM correctable errors are independent from the surrounding temperature in a server and rather depend on the utilization — cf. figure 2. Correctable errors are errors that can be corrected by the individual RAM modules transparently by exploring parity information and error correction codes (ECC).

Figure 2 - cf. [2]

In this figure, the failure rate of correctable errors correlates with the CPU utilization of a node in which case a generally higher error rate increases with temperature. In a low CPU utilization scenario, the error rate does not depend on the temperature.

A conclusion from these findings is that datacenter and cluster designers may be more flexible about cooling parameters and limits.

2. Analog Components Degrade with Age

Most hard disks still use magnetic disks and very sophisticated mechanics to store data. Just like your jeans wear out with time, the mechanics of a hard disk is said to wear out and to become more error-prone over its lifetime. Figure 3 shows the results of the analysis of failed hard disks and their AFR over time.

Figure 3 - cf. [1]

It is interesting to see that once a disk survives the first three months, its AFR decreases, then peaks after three years, and then decreases again. In numbers, the incidence for disk drives to fail after three months or three years is higher than after one year or five years, respectively. This observation can be explained by survival of the fittest”. Disks that have a manufacturing problem are likely to fail early. The same might hold for long running disks that proof to have an especially high manufacturing quality.

It seems to be clear that age is not a usable indicator for the likelihood of disk drive failure.

3. Digital Components do not Age

****In contrast to the aging behavior of hard disks, there is a correlation between age and failure rates for RAM modules over different hardware platforms and manufacturers — cf. figure 4.

Figure 4 - cf. [2]

This figure shows that the older a RAM module gets, the more likely it starts to fail. This degradation starts after around 10 months. In general, one third of all observed machines encountered at least one and in average over 22.000 correctable errors per year.

At first sight this finding does not look too bad since it only covers correctable errors which have no implications on the running system. But the studies found a 27-400 times higher probability for an uncorrectable error in one month if preceded by a correctable errors in the month before. Unlike a correctable error, an uncorrectable error in RAM usually leads to a shutdown of the affected node.

In addition, the research results indicate that, in contrast to common believe, failures are rather due to hard errors, i.e., permanent hardware defects, than soft errors caused by flipping bits.

The conclusion from these findings is that it is imperative to use ECC-protected memory to protect the system from a high probability (30%) of a memory failure. In addition, correctable memory errors must be taken seriously because they might indicate upcoming fatal uncorrectable errors.

**4. Hard Disk Fail Gradually **

****"Self-Monitoring Analysis and Reporting Technology” (SMART) has been introduced by hard disk manufacturers to allow users to access vital information about the health of their disks. All major system monitoring systems use the SMART values from a node’s hard disk to derive the health state of these disk and warn in case of beginning failure.

According to the research findings, the four SMART values “Scan Errors”, “Reallocation Count”, “Offline Reallocation Count”, and “Probational Count” may indicate upcoming disk failures if they are monitored over time. This means that while it is not possible to assess a disk’s health by looking at the SMART status once, the over time development of these four values may indicate a failure in the future.

Unfortunately, for 56% of all failed disks, the Google researches did not find relevant indication of degrading service quality. In other words, almost one out of two disks fails without a reliable information from SMART. This means, disks fail abruptly one in two times without any warning.

This makes redundancy of data (hardware or logic based) and preparations for a quick exchange of failing hard disks imperative.

Conclusion

****This article summaries large scale analyses of causes for RAM and hard disk failures. The general conclusion is that the likelihood of those failures as well as their development contradict common believes. Therefore, it is imperative to include these findings in your data center design and emergency response plans in order to deliver a reliable service to your customers.

[1] http://research.google.com/pubs/pub32774.html
[2] http://research.google.com/pubs/pub35162.html
All figures are excerpts from the corresponding papers.

★ What’s on your heap, mister?

Thu, 13 Dec 2012 08:53:00 GMT

If you ever wondered or have been confronted with the question, what actually is on your heap, the answer is surprisingly simple: Strings, Collections, and boxed numbers make the majority.

For example, see the statistics for Mac OS X 10.8 Calendar and Safari below. non-object represents direct allocations with malloc et al.

Top 8 for Calendar:

    COUNT     BYTES   CLASS_NAME
    53561  10591424   non-object
    19368   1033616   __NSCFString
    14132    226112   _NSObjectID_48_1d
     7053    789936   CalManagedAlarm_Alarm_
     3511    168528   __NSArrayM
     2781    177984   __NSCFDictionary
     1808     86784   __NSDictionaryM
     1555     49760   __NSCFNumber

Top 8 for Safari:

    COUNT     BYTES   CLASS_NAME
   200113  50402208   non-object
   111900   9927472   __NSCFString
    17341   1109824   __NSCFDictionary
    12519    600912   __NSDictionaryM
     9715    466320   __NSArrayM
     5122   2082400   __NSCFData
     3434    175600   __NSArrayI
     3392    108544   __NSCFNumber

But then, this is not surprising at all. Seriously, what else could there be on the heap if you think about it?!

Bugs and dynamically versus statically typed languages

Wed, 12 Dec 2012 13:29:00 GMT

Daniel Sobral about the conception of bugs in dynamically and statically typed languages:

Dynamically typed language proponents consider “bugs” to be things that the user of the software can cause it to do, while statically typed language proponents consider “bugs” to be things that users of the code can cause it to do.

Stackable Traits in Scala

Thu, 06 Dec 2012 10:47:00 GMT

Followup to the last article: Bill Venners has a thoughtful introduction to Stackable Traits which is a design pattern in Scala. I used Stackable Traits in the example to demonstrate the usefulness of Mixins.

★ To Mix in or not to Mix in

Mon, 03 Dec 2012 12:39:00 GMT

In his article “Composition over Mixins” Eric Meyer makes the case why Mixins should not be used, because a Mixin is

a violation of the SRP by definition.

On the hand, he is right. By using Mixins, different functionality is integrated into one class or object. At least at run time. On the other hand, Mixins actually help to separate responsibilities to different parts at the source code level and thus, at compile time.

For example, the following excerpt from a log processor in Scala consists of an interface LogProcess (line 1) and two* implementations LogDumper (line 12) and LogHBaseAdder (line 19). *The first just prints the log entry to the console (line 14) and the second adds it to an HBase table (line 21). These two implementations are mixed into the default implementation of the interface creating a single object (lines 28-29) that supports both, printing and adding.

abstract class LogProcessor( val filename: String ) {

  def process() : Unit = {
    Source.fromFile( filename ).
      getLines.map.( line =>
        processEntry( LogEntry(line) ) )
  }

  protected def processEntry( logEntry: LogEntry ) : Unit = {}
}

trait LogDumper extends LogProcessor {
  abstract override protected def processEntry( logEntry: LogEntry ) : Unit = {
    println( logEntry.toString )
    super processLogEntry logEntry
  }
}

trait LogHBaseAdder extends LogProcessor {
  abstract override protected def processEntry( logEntry: LogEntry ) : Unit = {
    htable put logEntry.createPut( family )
    super processLogEntry logEntry
  }
}

object Runner {
  def main( args: Array[String] ) {
    val lp = new LogProcessor( args(0) )
      with LogDumper with LogHBaseAdder
    lp.process
  }
}

Of course, this is also possible using composition. But using Mixins, both, LogDumper and LogHBaseAdder, are not aware of each other. Even the interface does not need to know about this. So we do achieve a separation of responsibility and only wire the functionality together when creating the object.

So maybe Mixins are not that bad at all.

Buster.JS - Browser JavaScript testing toolkit

Wed, 28 Nov 2012 12:52:00 GMT

Speaking of JavaScript unit testing. Checkout Buster.JS, too.

Testacular — JavaScript Testrunner

Wed, 28 Nov 2012 12:49:00 GMT

Google released the JavaScript test runner Testacular which enables running JavaScript tests in the console. In this way, executing tests can be easily integrated into your IDE. Testacular is unit test framework agnostic and the developers demonstrate it using Jasmine.

There is also a short introduction video.

Podcast about Continuous Delivery from the Source

Fri, 12 Oct 2012 12:00:00 GMT

There is a Podcast about Continuous Delivery from one of the authors of “Continuous Delivery: Reliable Software Releases Through Build, Test, and Deployment Automation” and Martin Fowler.

(via Thomas Ferris Nicolaisen on the Bonn Agile Meetup mailing list)

Done with Scrum

Mon, 01 Oct 2012 12:00:00 GMT

Jimmy Bogard gives 4 reasons why he’s done with Scrum. While his observations are valid, I think he makes the wrong conclusion. He’s not done with Scrum, but he evolved beyond strict, by-the-book Scrum. He says:

I remember just getting bored to tears listening to discussions around stories I wasn’t developing on to begin with. Eventually, we had to ask the question, “are these meetings providing the value we are paying for”. Yes, there was some value, but not near enough to warrant so much expense. I’m sitting in a meeting, thinking, “can’t I just start actually developing software”?

Instead, just about everything was JIT’d.

That’s exactly what I mean. From a strict, by-the-book Scrum, he (and this team) evolved to an agile application of the Scrum principles.

Ultimately, our goal is to continually deliver success.

And that’s the goal of Scrum (and all agile processes in general).

But he’s right about the difficulties of deploying Scrum in an organization.

To Comment or not to Comment

Mon, 10 Sep 2012 12:00:00 GMT

On slashdot the question was asked what developers think about comments. There are two dominant perspectives: 1. Code without comments becomes incomprehensible over time and 2. code should be self-explanatory without comments.

if you can’t fit the documentation into your method (and variable names), that method is likely too long and complicated.

This is foolish arrogance. In my thirty years in this profession I have worked with many people who thought their code was ‘self documenting’; all of them were wrong, and faced with their own code two years later I doubt any of them could immediately follow it. I’ve only ever worked with one software engineer who, in my opinion, documented enough; I strive to match his standards in my own code but I know I don’t always succeed.

I think this is the wrong way to argue about comments, because comments rot over time — similar to code without tests.

But there are no compiler checks or tests that verify, if a comment fits the code it documents. Over time, the comment rots and instead of helping to understand the code, the comment becomes misleading. This is far worse than code without comments.

There is no general silver bullet to this problem. But one thing is perfectly clear: The code is the truth. It seems sensible to follow clean coding principles, use test driven development, and peer reviews.

TDD and Functional Programming - A perfect match

Tue, 04 Sep 2012 12:00:00 GMT

Daniel Sobral writes about “Bugs, TDD and Functional Programming”. Hey says that debugging a shelve is easier than debugging software because for the physical shelve you can look at each part separately. For software, this is usually more difficult. But:

I see both TDD and functional programming as ways to change that. For TDD, […] If some bug shows up (in the test), then it must be related to the change you just made. Since changes are supposed to be small if you do it right, then the code path you must follow to find the bug should be quite restricted.

The same holds for functional programming […]. A program in functional programming is supposed to be a composition of functions, and each function should be referentially transparent — side-effect free.

Add both together, and software starts looking a lot more like building an airplane or a bridge.

Since using TDD, I often observed that I tend to write code in a more functional style. It is natural to implement the requirements of an isolated test by writing production code without outside dependencies a.k.a. side-effect free code.

One more reason to get familiar with functional programming.

Functional Programming for the Object Oriented Programmer

Mon, 27 Aug 2012 12:00:00 GMT

Uncle Bob reviews the book Functional Programming for the Object Oriented Programmer:

We need something to bridge the gap between the huge population of OO programmers, and the growing need for functional programmers.

And continues about functional programming in general:

you’ll also learn a lot about OO that you may not have known before.

I could not agree more. When I discovered LISP ten years ago, I realized two things. First, there is much, much more to discover in programming than we Algol 60 programmer would think. Second, this holds especially for object oriented programming. The C++/Java point of view is just one way to apply OO.

Stop hesitating and tip a toe into functional programming.

How Google tests its APIs

Tue, 21 Aug 2012 15:04:00 GMT

In “Testing Google’s New API Infrastructure” Anthony Vallone describes how Google tests its public APIs which are available for different programming languages and platforms:

As of this writing, we have released 10 language-specific client libraries and 35 public APIs built on this infrastructure. Also, each of the libraries need to work on multiple platforms. Our test space has three dimensions: API (35), language (10), and platform (varies by lib).

Instead of testing all possible combinations, they use a dedicated Test API:

We want to avoid creating library-specific tests, because this would lead to mass duplication of test logic. The obvious solution is to create a test library to be used by all tests as an abstraction layer hiding the various libraries and platforms. This allows us to define tests that don’t care about library or platform.

See the figures for details.

Rootbear: Run Java Code on GPU

Mon, 13 Aug 2012 12:00:00 GMT

From their description on github:

The Rootbeer GPU Compiler makes it easy to use Graphics Processing Units from within Java.

And it has been developed in TDD style:

Rootbeer was created using Test Driven Development and testing is essentially important in Rootbeer. Rootbeer is 20k lines of product for and 7k of test code and all tests pass on both Windows and Linux. The Rootbeer test case suite covers every aspect of the Java Programming language except:
1. native methods
2. reflection
3. dynamic method invocation
4. sleeping while inside a monitor.

(via slashdot)

Property based Testing for Domain Models

Mon, 30 Jul 2012 12:00:00 GMT

Debasish Ghosh describes the benefits of property based testing compared to traditional xUnit style testing. He advocates to use libraries like ScalaCheck ((Similar libraries are available for many programming languages; cf. http://en.wikipedia.org/wiki/QuickCheck)) where only the property to satisfy by the production code is described and the library generates the test data to check the property with:

I don’t need to construct concrete data by hand (in fact this is what makes xUnit based frameworks a sophisticated manual testing system - it only automates the execution part of your testing).

Example:

[code]
property(“Enrichment of a trade should result in netvalue > 0”) {
forAll((a: Trade) =>
enrichTrade(a).netAmount.get should be > (BigDecimal(0)))
}
[/code]

This method shifts writing test from how to test to what to test.

With Proper TDD, You Get That

Fri, 27 Jul 2012 12:00:00 GMT

Dariusz Pasciak describes how developing software without TDD is like and concludes:

Test Driven Development is an art that every software developer ought to learn and practice to at least some extent. Even if you don’t think it’s useful, even if you think it’ll be a waste of time - if you have never tried it before (for real), then try it. And I’m not talking about one week or two weeks of “ok fine, I’ll give this thing a shot”. I mean really get yourself motivated, believe that there are many benefits to reap from this practice, and invest valuable time and energy to figure this thing out for good. Then, once you get it down, use it on at least a few projects, see the difference it makes. Treat it as a college course, or as preparation for a marathon.

And by all means don’t just do it so that you can say you’ve done; if you approach it with that kind of attitude then you’ll have wasted your time. Don’t cut corners. If something is “too hard to test”, don’t skip it - spend hours if you must, but figure out a good way to test everything. Explore different ways of doing this, get help from others who live and breathe this, and really figure this thing out. It’s worth it.

Please, every doubters and hesitaters, read this article. Seriously, read it!

10 Application Performance Tuning Tips

Thu, 26 Jul 2012 12:59:00 GMT

Mirko Novakovic gives “10 Application Performance Tuning Tips”. I like the first two tips the best:

1. Define the requirements
2. Measure don’t guess

I’m regularly shocked how casual many developers are about these two tips. Many developers start to write software without considering what exactly they are trying to achieve. But without requirements you cannot check, if your software is correct; as Mirko points out for performance requirements:

How do you measure “fast”? Is 8 second fast? Or 1 second?

The same holds for premature optimization lacking a sophisticated analysis. In this sense sophisticated does not mean running your software with some sample data and a profiler on your development machine. It means monitoring your software in production use over time. That is where you will find the real bottlenecks.

Leading Change towards Test Driven Development

Fri, 20 Jul 2012 12:00:00 GMT

Zeger Van Hese summarizes a presentation of Keith Klain about how to change a company and move towards better testing mindsets.

If you intend to change your organization’s mindset towards testing, this is an excellent reference.

qTrace: Easily Document Bugs in Web-UI

Wed, 18 Jul 2012 12:00:00 GMT

qTrace is a nice tool that eases the documentation of bugs found by manual Q&A in Web-based user interfaces.

★ Type Systems Save You from Bugs

Mon, 16 Jul 2012 12:00:00 GMT

In Types and Bugs Rafael Ferreira discusses the advantages of type systems that help to discover bugs which unit and integration tests cannot find. He references a very interesting paper in which the author describes how he discovered bugs by porting an algorithm from Python to Haskell. Rafael stats

Most of the bugs fell into one of two categories:

Assuming that a variable always references a valid value when it can contain a null value.

Referencing constructs that no longer exist in the source.

NULL is definitely the most annoying concept ever invented in programming. Briefly, it is just a special construct signaling invalid values. NULL is the source of a plethora of bugs, e.g., when “Dereferencing NULL Pointer, without a Seg Fault”. Today, we have programming languages that express invalid values much cleaner and type safe. See for example Scala’s Option type.

Rafael continues

some method or variable was present but changed, perhaps it was renamed or subsumed, and not all references were updated to reflect the change. Even pervasive unit tests can’t hope to catch these kinds of regressions, as the problem is found on the integration between units of code; the units themselves are just fine. A type system helps when the change affects the signature of the referenced construct, which is often but not always.

You cannot always chose the programming language, because of dependencies. But if you can, use languages that have sophisticated type systems. They safe you from a lot of trouble just by running the compiler.

Quality is mixing Development and Testing

Wed, 11 Jul 2012 18:58:00 GMT

In his book “How Google Tests Software” James Whittaker writes

Quality is achieved by putting development and testing into a blender and mixing them until one is indistinguishable from the other.

This is the essence of the mindset that you need, if you want to successfully apply Test Driven Development.

Actually, that is the mindset you need, if you want to succeed as a developers at all, today.

Google: Testing on the Toilet

Mon, 09 Jul 2012 08:27:00 GMT

Today, I stumbled across an old post of Google’s Testing Blog. “Introducing ‘Testing on the Toilet’” suggests to plaster your company’s toilet walls with How-Tos and information about how to test software.

In the initial phase, when you are introducing Test Driven Development into your company, the mindsets of the developers must change. This is the most crucial phase which determines the success or failure of the implementation of TDD.

Making TDD an ubiquitous element in your working environment you cannot escape might be annoying, but it definitely will help to get the ideas into the developers minds.

Handout to download: Test Driven Development

Fri, 06 Jul 2012 12:29:00 GMT

Test Driven Development is a safe way to keep your code base clean and agile. It helps to maintain old and implement new features.

This document targets developers and shows how the basic idea of Test Driven Development can be applied in your daily programming work. Furthermore, it gives an introduction to the most important aspects of Test Driven Development and motivates their application in your company.

Download “Test Driven Development”

Handout to download: Introducing Test Driven Development

Wed, 04 Jul 2012 08:00:00 GMT

Introducing Test Driven Development in your organization is a challenging task. Test Driven Development is not just a development technique, but it is a development mindset. It is therefore important that the mindset of your team changes. But changing mindsets is even more challenging.

This document aims primarily at managers and gives a brief introduction to Test Driven Development in general. Further, it describes the psychology of change. It shows which aspects of human nature needs to be considered when Test Driven Development shall be introduced in your company successfully.

Download “Introducing Test Driven Development”.

Effective Leadership Through Communication

Fri, 29 Jun 2012 10:08:00 GMT

In his article “Effective Leadership Through Communication” Mike Jansen presents his experiences as a leader of development teams. I really like them as they are very close to my attitude as a Scrum Master.

Especially, I like his observation:

The switch between developer and project lead can be difficult. Leads often come from the ranks of the strongest developers, but the skill set required from a lead is very different from the set exercised on a regular basis for a developer, especially in the realm of communication.

The best programmer is not necessarily the best team leader. This is very important for companies, because they need to realize that promotion is not always the best way to reward excellence.

Test Driven Assembly

Fri, 08 Jun 2012 17:48:00 GMT

Michael Baker describes how he developed a game in assembly using Test Driven Development.

No excuses anymore: If you can use TDD for assembly, you can use it for everything.

First Steps in Unit Testing

Wed, 06 Jun 2012 07:54:00 GMT

Gil Zilberfeld gives an excellent introduction to unit testing. Absolutely worth a read.

Legacy code is code without tests

Thu, 31 May 2012 15:30:00 GMT

Michael C. Feathers says in his book “Working effectively with Legacy Code”

Legacy code is simply code without tests

and

Code without tests is bad code. It doesn’t matter how well written it is; it doesn’t matter how pretty or object-oriented or well-encapsulated it is. With tests, we can change the behavior of our code quickly and verifiably. Without them, we really don’t know if our code is getting better or worse.

Perfect definition. Nothing to add.

Mit 7 Schritten zum perfekten Unittest

Mon, 28 May 2012 16:09:00 GMT

Diese 7 Schritte schlagen Tim Ottinger und Jeff Langr vor:

Don’t sweat the initial name

Write the test […] Use AAA or Given-When-Then

Get it to pass

Rename based on content

Rename based on a holistic fixture view

Rename and reorganize other tests as appropriate

Reconsider the name with each revisit

An diesen Schritten gefällt mir besonders die immer wiederkehrende Neubewertung des Namens. Es ist ein Zeichen dafür, dass sich die Absicht des Tests mit Änderungen des Produktivcodes ebenfalls ändert.

Tests sind genauso wenig statisch wie der Produktivcode. Auch sie müssen kontinuierlich gewartet und neu bewertet werden. Es gilt wie immer: Es gibt keinen Qualitätsunterschied zwischen Test- und Produktivcode.

★ Softwareentwicklungsprozesse entwickeln sich mit der Zeit

Sun, 13 May 2012 12:24:00 GMT

Das Dreyfus Modell klassifiziert das Erfahrungsniveau von einzelnen in ihrem Arbeitsfach. Ein Beispiel: Fehlt Salz in der Suppe benötigt der Küchenlehrling exakte Angaben in Gramm. Der Chefkoch schmeckt ab, wirft eine Prise Salz in die Suppe und es passt. Er könnte dem Lehrling aber nicht sagen, wie viel Gram richtig wären; eine Prise eben.

Im Artikel Our Development Process: 50 Months of Evolution beschreibt Michael Dubakov die Veränderung im Softwareentwicklungsprozess seiner Firma über vier Jahre. Sie begannen mit festen Regeln. Diese Regeln wurden mit der Zeit von flexiblen Best Practices abgelöst.

Offensichtlich haben sie wie der Lehrling zu Beginn klare Vorgaben gebraucht und handeln nun eher aus ihrer Intuition heraus. Das Dreyfus Modell scheint also auch für Gruppen zu gelten.

Man sollte diese Erkenntnis berücksichtigen, wenn man neue Methoden und Prozesse in seinen Teams einführt. Zuerst bedarf es klarer, strikter Reglen; mit der Zeit handelt man automatisch und die Reglen können flexibler werden.

Die 7 Verschwendungen von Arbeitskraft

Wed, 09 May 2012 17:44:00 GMT

Im Artikel The Seven Wastes stellen Tim Ottinger und Jeff Langr eine Liste von 7 Punkten auf, wie Arbeitskraft verschwendet wird.

Partially done work

Extra Features

Relearning

Hand-offs

Task switching

Delays

Defects

Ich finde 1. und 2. wichtig und insbesondere 4. für die Agile Softwareentwicklung wichtig:

Wenn ich eine Aufgabe nur zu 80% umsetze, fehlen 20%. Sie ist also nicht fertig. Bevor man eine neue Aufgabe anfängt, sollte man die aktuelle abschließen.
Wenn ich eine Aufgabe zu 120% umsetze, dann bin ich seit 20% fertig. Ich könnte längst die nächste Aufgabe angehen.
Wenn eine Aufgabe fertig ist und jemand anderes mit dem Ergebnis weiterarbeit, dann bleibt es meine Verantwortung, wenn Fehler oder Fragen auftauchen.

Warum Unternehmen bei der Einführung von Agiler Softwareentwicklung scheitern

Mon, 07 May 2012 19:45:00 GMT

Einer der Gründe dafür ist:

Take Kanban for example, or Scrum. They both have some fairly simple rules, like chess, but they are hard to turn into real success. Also like chess. So what do the experts, i.e. trainers do? They go around teaching the rules, perhaps getting things started, then they leave. Leaving the client to face the hard bits alone.

Es klingt einfach, fast simple. Doch die Umsetzung muss von Experten begleitet werden. Schlussendlich ist Agile Software Entwicklung nicht eine weitere Methode zur Softwareentwicklung, sondern eine neue Geisteshaltung:

[…] Agile is a mindset, not a method and that’s the important point. And what is needed is a change in mindsets.

Agile Softwareentwicklung ist eine vollständig neue Arbeitskultur und -einstellung.

Ein Unternehmen kann nicht von heute auf morgen agil werden, nur weil es den Regeln folgt. Wie beim Schach genügt es nicht die Regeln zu kennen, sondern es ist ein langer Lernprozess, der individuell begleitet werden muss.

(via Craig Smith)

★ Downloads - Beispiele für TDD

Sat, 05 May 2012 14:55:00 GMT

Wie beim Erlernen einer neuen Programmiersprache muss Test Driven Development erfahren werden: Es genügt nicht nur, darüber zu lesen, man muss es selbst praktisch ausprobieren.

Um Ihnen den Anfang zu erleichtern, können Sie auf der Downloadseite Beispielimplementierungen der binären Suche in Python und Scala herunterladen, die ich mit Hilfe von TDD umgesetzt habe.

Ich freue mich über Fragen und Anregungen zu den Beispielen.

★ Keine Zeit für Tests oder PHPs fehlgeschlagener Sicherheitspatch

Sat, 05 May 2012 12:09:00 GMT

Wer Test Driven Development umsetzt findet mit Hilfe seiner Tests Vertrauen in die eigene Codebasis. Je gründlicher TDD umgesetzt wird, desto höher ist das Vertrauen. Tests schützen aber nicht grundsätzlich vor allen Bugs.

Deshalb ist es verständlich, dass im JDK neun Jahre lang ein Bug schlummerte, der trotz TDD nicht aufgefallen ist. Erst 2006 wurde der Bug in Binarysearch entdeckt.

Unverständlich ist es jedoch, einen Patch zu veröffentlichen, der den Bug nicht schließt:

Die am gestrigen Donnerstag veröffentlichten Updates auf die PHP-Versionen 5.3.12 und 5.4.2 sind fehlerhaft. Darauf weisen die Entdecker der Schwachstelle hin, welche eigentlich durch die Updates behoben werden sollte.

Gerade wenn der Druck groß und die Zeit knapp ist, muss TDD konsequent eingesetzen und der Patch auf Herz und Nieren getestet werden. Solche Fehler kosten schnell die Reputation des Projekts oder der Firma.

Neues von Java

Thu, 03 May 2012 12:49:00 GMT

Vor einigen Tagen wurde das vierte Update zu Java 7 veröffentlicht. Alex Blewitt gibt eine kurze Zusammenfassung. Aus meiner Sicht sind die wichtigsten Neuerungen:

Oracle beginnt in dieser Version, Technologien aus Suns HotSpot VM und Oracles JRocket VM miteinander zu vereinen. Das klingt sehr spannend, denn beide virtuelle Maschinen haben komplementäre Stärken.
Der neue Garbage Collector G1 kann durch Setzen eines Flags ausprobiert werden.
Es gibt eine Mac OS X Version. Zukünftige Updates für Mac OS X werden von Oracle und nicht mehr von Apple kommen. Hoffentlich werden dadurch Sicherheitsfehler schneller behoben.

★ Wie und woran ich heute arbeite

Tue, 01 May 2012 09:54:00 GMT

http://ueberallbuero.de/wp-content/uploads/2012/04/Lukas-Pustina1.jpgWas bisher geschah…

Vor anderthalb Jahren erschien der letzte Artikel auf Überallbüro.de. Seitdem haben mich viele Leser angeschrieben und gefragt, wann es weiter gehen würde. Meine Antwort war stets:

Ich habe alles geschrieben, was ich zum Thema “fokussiert arbeiten, wann und wo man will” weiß.

Natürlich hat sich meine Arbeitsweise seitdem weiterentwickelt. Was geblieben ist, was sich geändert hat und woran ich heute arbeite, erzähle ich in diesem Artikel.

Was geblieben ist

Die Prinzipien meiner Arbeit sind gleich geblieben:

1. Halte alles digital fest, damit Du überall und jederzeit darauf zugreifen kannst.
2. Nutze Papier und Stift, wann immer es schnell oder unbeschränkt gehen muss.
3. Arbeite fokussiert und ohne Ablenkungen, damit du produktiv voran kommst.

Die Werkzeuge meiner Wahl sind nach wie vor Evernote, Remember the Milk (RTM) und Dropbox. Für spontane Ideen oder Brainstormings nutze ich Notizbücher und Post-Its. Meine handschriftlichen Notizen übertrage ich abends oder scanne sie mit meinem Dokumentenscanner. Ich versuche, so wenig Werkzeuge wie möglich einzusetzen.

Für die fokussierte Arbeit verzichte ich weiterhin auf Selbstaustrickserei wie temporäre Websperren. Ich nutze die Pomodoro-Technik und habe mir genügend Selbstdisziplin erarbeitet, mich während eines Pomodoros nicht ablenken zu lassen.

Was sich geändert hat

Evernote hat vor einiger Zeit die Funktion eingeführt, Links zu einzelnen Notizen (en) zu erstellen. Diese Links kann man nutzen, um Notizen miteinander zu verlinken. Sie funktionieren auch extern im Browser. Ein Klick auf den Link ruft die passende Notiz auf.

Seitdem hat sich meine Aufgabenverwaltung aus RTM nach Evernote verschoben. RTM enthält jetzt zu Vorgängen nur noch den nächsten Schritt sowie von Projekten und Vorgängen losgelöste Einzelaufgaben. Die Vorgangsaufgaben erweitere ich mit einem Link zur passenden Notiz in Evernote. So gelange ich per Klick von RTM zu Evernote. Auf diese Weise kann ich besser nachhalten, welche Schritte zu einem Vorgang bereits erledigt worden sind und welche noch anstehen. Zusätzlich kann ich Anmerkungen zu den einzelnen Schritten festhalten. Während der Wochenplanung gehe ich regelmäßig sämtliche Vorgänge durch, um keine Schritte oder Fristen zu versäumen.

Woran ich heute arbeite

Überallbüro.de war inspiriert durch meine Arbeitsweise und dem Austausch mit meinen Kunden, Kollegen und Freunden. Das Ziel war es, meine Methode für das fokussierte Arbeiten, wo und wann man will zu präsentieren. Jeder sollte sie für seine tägliche Arbeit anwenden können. Insbesondere als Softwareingenieur habe ich von meiner konzentrierten Arbeitsweise profitiert.

Softwareentwicklung ist stets eine Teamarbeit; heute mehr denn je. Der erfolgreichen Teamarbeit beim Planen und Durchführen von Projekten widme ich mich zur Zeit in meinem neuen Projekt: blog.test-driving.de. In diesem Linkblog verweise ich auf spannende und hilfreiche Artikel aus der Welt der Agilen Softwareentwicklung. Ich blogge zu Tools, Methoden, neuen Erkenntnissen und Erfahrungsberichten, die durchaus auch für den Arbeitsalltag von Nichtprogrammierern relevant sind.

Blog.test-driving.de ist zur Zeit in der Betaphase. Hiermit möchte ich alle Leser von Überallbüro.de einladen, die Ersten zu sein, meinen neuen Blog live auszuprobieren. Ich freue mich auf Kommentare und Anregungen sowohl inhaltlicher als auch gestalterischer Art. Wenn Euch der Blog gefällt, dann informiert Eure Kollegen und Freunde, so dass wir wie auf Überallbüro eine breite Diskussion anregen.

Zum Schluss

Überallbüro werde ich weiterführen, wann immer es etwas zu berichten gibt. Fragen und Kommentare beantworte ich gerne und ausführlich wie bisher. Falls Ihr also Anregungen habt: Immer her damit.

★ TDD ist eine Gewohnheitsänderung

Fri, 27 Apr 2012 13:28:00 GMT

Test Driven Development ist keine Erweiterung zu unserer täglichen Entwicklungsarbeit. Es ist ein neuartiger Ansatz, der erlernt und erfahren, verstanden und verinnerlicht werden muss, bevor er seine volle Wirkung entfaltet. Wenn ich über TDD spreche, es vorstelle und rate, es konsequent einzusetzen, höre ich oft das typische “Ja, aber”:

Ja, TDD ist prima, aber wenn ich unter Druck bin, die Abgabefristen näher rücken, dann hält es mich auf.

So oder so ähnlich wird sich entschuldigt, wenn man doch wieder in seine alten Gewohnheiten verfällt. Dann weichen systematische Tests schwer reproduzierbaren, manuellen Einzelfallbeispielen und testbarer Code langen, in einander verschachtelten Codeblöcken.

Gewohnheiten zu ändern ist ein harter Kampf. Man muss an sich arbeiten, zusätzliche Kraft aufwenden und seinen inneren Schweinehund überwinden. Corsey Haines sagt dazu:

If you find that you are faster doing it in a way that does not conform to what you consider “good” and “right,” then you are suffering from a deficiency in your skills. Period. The techniques that you fall back on when the deadline looms are the only techniques that you can call your own; everything else is something you are still learning. How quickly they become ‘your own’ is a question of how much you practice. If you have a technique that you think is ‘better’ than how you do it when the deadline looms, you owe it to yourself to practice it.

Natürlich ist TDD zu Beginn eine Umstellung, alte Gewohnheiten müssen abgelegt und neue erarbeiten werden. Aber TDD erleichtert die Arbeit, es beschleunigt die Entwicklung.

Also, Schweinehund überwinden und noch heute Tests schreiben!

Cargo-Bot, das erste auf iOS entwickelte Spiel

Tue, 24 Apr 2012 12:55:00 GMT

Das iPad-Spiel Cargo-Bot wurde mit Hilfe von Codea auf dem iPad prototypisiert.

Das ist nur der erste Schritt hin zur Entwicklung für iOS unter iOS. Stay tuned …

(via Daring Fireball)

Light Table, ein neues IDE-Konzept

Tue, 24 Apr 2012 10:43:00 GMT

Light Table ist ein neues Konzept für IDEs. Besonders hervorzuheben ist

Instant feedback […] The lispers among us are used to using the REPL to have an environment where we can try things out. Light Table takes this idea as far as it can […] This lets you see how values flow through arbitrarily complex groups of functions.

Das Video zeigt die wichtigsten Ideen von Light Table anschaulich — unbedingt anschauen:

[vimeo 40281991]

Ich bin gespannt, was sich daraus entwickelt. Light Table befindet sich zur Zeit in der Finanzierungsphase bei Kickstarter. Die Autoren planen eine Beta Ende des Jahres und eine erste Version im Mai 2013.

Es ist auf alle Fälle an der Zeit, das Verwalten von Code in Dateien abzulösen und bessere Werkzeuge als Texteditoren mit Verzeichnisübersicht zum Programmieren zu entwickeln.

(via @Uncle Bob)

Die 3 Gesetze des Test Driven Development

Mon, 23 Apr 2012 09:21:00 GMT

Nach The three Laws of TDD legt Uncle Bob folgende Gesetze des Test Driven Development fest:

You are not allowed to write any production code unless it is to make a failing unit test pass.

You are not allowed to write any more of a unit test than is sufficient to fail; and compilation failures are failures.

You are not allowed to write any more production code than is sufficient to pass the one failing unit test.

Und fügt direkt hinzu:

Now most programmers, when they first hear about this technique, think: “This is stupid!” “It’s going to slow me down, it’s a waste of time and effort, It will keep me from thinking, it will keep me from designing, it will just break my flow.”

Ist es dann überhaupt sinnvoll oder gar machbar, die Gesetze zu befolgen? Ja, denn:

A minute ago all their code worked!

Der gesamte Code vor der letzten Änderung funktioniert!

Setzt man diese Methode konsequent ein, so hat man stets funktionierenden Code, schließlich hat man nur eine Funktionalität nach der anderen hinzugefügt. So fallen Debugging-Sessions aus.

Die Gesetze klingen seltsam vielleicht sogar absurd. Aber wann immer wir Neues lernen, ist es zu Beginn ungewohnt. Ich setze diese Methode begeistert ein und empfehle, sie einige Zeit auszuprobieren.

(via Stephan Kämper)

Wie viele Tests sind genug? 1000 mal mehr!

Thu, 19 Apr 2012 09:05:00 GMT

Wer mit Test Driven Development beginnt, stellt oft diese Frage. Erst mit der Zeit versteht man, dass Tests kein “Zusatz” sind, sondern ein ganz normaler Bestandteil der Codebasis; und zwar ein sehr großer Bestandteil.

Im Podcast von heise Developer zu Testing & Softwarearchitektur habe ich gelernt:

Microsoft setzt für jeden Programmierer einen Tester ein

Das verdeutlicht den Stellenwert des Testens bei Microsoft. Ein besonders Beispiel hat Stephan Kämper gestern in seinem Vortrag zu Test-Automatisierung geben:

SQLite library 3.7.8 ~ 77.6 KSLOC of C code

Test code & scripts ~91392.4 KSLOC (1177 × as much)

Sqlite hat mehr als 1000 mal mehr Testcode als Produktivcode. Wem das verrückt erscheint, sollte bedenken, dass Sqlite die am häufigsten eingesetzte Datenbankengine der Welt ist. Zum Beispiel läuft die auf jedem iOS und Android Gerät.

Wichtig: Tests sind kein Zusatz zum Code. Sie werden nicht nachträglich geschrieben. Tests sind der Code.

Continuous Deployment bei Facebook

Wed, 18 Apr 2012 17:33:00 GMT

Continuous Deployment ist die Weiterführung von Continuous Integration: Wenn der Code die Tests besteht, wird er automatisch im Produktivsystem ausgerollt. Chuck Rossi, Facebooks Head of Release Engineering, spricht mit Ryan Paul über Facebooks Ausrollungsstrategie:

Facebook typically rolls out a minor update on every single business day. Major updates are issued once a week

Facebook weicht dafür die Trennung zwischen Entwicklung und Betrieb auf:

An important aspect of Facebook’s development culture is the idea that developers are fully responsible for how their code behaves in production. This philosophy mirrors the “DevOps” movement, which encourages lowering the wall between software development and IT operations.

Den Gegnern von Continuous Deployment kann ich nur sagen: Wenn der Code nicht produktreif ist, warum habt Ihr ihn dann eingecheckt?

(via Mitch Pronschinske)

Wie man gute Userstorys herleitet

Sat, 14 Apr 2012 13:26:00 GMT

Userstorys sind die Grundlage von Prozessen der Agilen Softwareentwicklung. Sie beschreiben, was sich der Benutzer von der zu entwickelnden Software wünscht. Wie leitet man Userstorys her und was sind gute Userstorys?
Adam Boczek versucht sich dieser Frage über seine 5 Gesetze zur Backlog-Partitionierung zu nähern:

a partition is a set of subsets that divide up some universe such that every element in the original universe ends up in one and only one of the subsets [..] In case of the user stories these subsets are called epics

Aus Epics werden im weiteren Verlauf von Scrum Userstorys erarbeitet. Die Gesetze lauten:

Law of Disjunction: partitions must be true partitions in the mathematical sense.

Law of Synergy: partition definitions must be appropriate to the problem at hand.

Law of Equal Partition Size: the numbers of epics in a partition must be appropriate.

Law of Equal Content Size: the size of the epics in a partition must be roughly equal.

Law of Fortress: the interactions between subsets in the partitions must be minimal and well defined.

Die Gesetze geben einen sinnvollen Anhaltspunkt, der unsere Intuition beim Erstellen von Userstorys unterstützt. Mal sehen, wie sich diese Gesetze in der Praxis bewähren.

Warum Scrum fehlschlägt und wie der Neustart gelingt

Sat, 14 Apr 2012 12:37:00 GMT

Agile Softwareentwicklung einzuführen ist ein steiniger Weg. Schlägt zum Beispiel Scrum fehl, schiebt man die Schuld auf Scrum. Rafael Maranzato beschreibt in Moving Back to Scrum and Scaling to Scrum of Scrums in Less than One Year die wahren Gründe für das Fehlschlagen von Scrum bei Universo Online SA so:

Focus on rules instead of values

Personal conflicts

Inadequate management intervention

Misunderstanding of Scrum

Zum Glück zeigt er aber auch, wie es gelang, Scrum erfolgreich einzuführen:

Focus on values instead of rules: commitment, transparency and teamwork

Scale Scrum with feature teams

Take baby steps - and evaluate them

Nach meiner Erfahrung sollte man noch die folgenden Punkte hinzufügen:

Änderung beginnt im Kopf: Zuerst beim Management, dann beim Team
Sei auf Fehler und Rückschläge vorbereitet
Nutze externe Erfahrungen wo und wie immer möglich

10 Software-Designprinzipien von gov.uk

Tue, 10 Apr 2012 09:49:00 GMT

“Ja, klar” denkt man, wenn man die Designprinzipien der Macher von Gov.uk liest:

Start with needs

Do less

Design with data

Do the hard work to make it simple

Iterate. Then iterate again

Build for inclusion

Understand context

Build digital services, not websites

Be consistent, not uniform

Make things open: it makes things better

Jeder Punkt wird prägnant und anschaulich auf der Webseite erläutert.

Diese Prinzipien sollte sich jeder Entwickler unter sein Kopfkissen
legen: So entwickelt man Software!

PS Darüber hinaus ist die Seite ein Beispiel für gelungenes Webdesign und
schon deswegen einen Besuch wert.

(via Thomas Ferris Nicolaisen auf der “Bonn Agile Meetup” Google Group)

Vom Java zum Scala-Shop

Tue, 03 Apr 2012 09:02:00 GMT

Graham Tackley, Web Platform Team Lead bei guardian.co.uk, spricht in How We (Mostly) Moved from Java to Scala über die Migration der Guardian Webseite von Java zu Scala.

Ab Minute 27 kommt er auf den Vorwurf zu sprechen, Scala sei zu komplex:

One of the expectations people have when coming [to Scala] is to go to a tutorial and be able to understand every single line of Scala code.

Was natürlich bei keiner Programmiersprache geht.

But really, it actually comes down to 4 things that fundamentally change the way you write code and that petrify Java developers. […] And they can be explained on 4 slides.

Und das gelingt ihm auch sehr gut.

Ein spannender Vortrag, der darüber hinaus erklärt, warum sich
der Guardian für Scala + Lift + Apache Solr und gegen Django + Python
bzw. Java + Spring entschieden hat. Must see!

★ Ob Scala zu komplex ist, liegt an Dir selbst

Fri, 30 Mar 2012 11:42:00 GMT

Julio Faerman vergleicht in Scala or Java? Exploring myths and facts Scala mit Java. Dabei zeichnet er das Bild, wie Scalas Mächtigkeit Programmierer überfordert. Einzig bleibt die Feststellung, dass Scala zu komplex sei, wenn man die Konzepte der Sprache nicht verinnerliche:

The same features that can make Scala more productive can also make it unreadable.

In der Grundschule wurde mir erklärt, dass 2 * 21 = 42 ist. Das genügt bereits für die meisten Rechnungen im täglichen Leben. Im Studium lernte ich, dass hinter dieser simplen Rechnung Körperaxiome, Vektorräume, die Kantorsche Mengenlehre und schlussendlich die Peanoaxiome stecken.

Diese mathematischen Konzepte muss ich aber nicht anwenden, um rechnen zu können. Ich muss nicht alle Konzepte von Scala einsetzen, um erfolgreich zu programmieren. Ich nutze nur diejenigen, die ich wirklich verstanden habe.

Der wahre Grund für die Überforderung

Es ist die Erfahrung der Programmier; und die ist sprachunabhängig. Verständlicher Code hängt allein vom Programmierer ab, der den Code schreibt. Gerade das ist die wesentliche Aussage von Clean Code. Man kann in jeder Programmiersprache sauber und für andere verständlich programmieren.

Sauber zu programmieren ist die Fähigkeit, die wir erlenen müssen; Sprachkonzepte folgen von allein.

Keynote als Universaldesigner

Thu, 29 Mar 2012 12:52:00 GMT

Paul Woods nutzt Apples Präsentationssoftware Keynote als Universalwerkzeug, um Designs zu entwickeln. Er zieht es sogar Adobes InDesign vor:

Keynote is an incredibly powerful design tool. Less then one year later, I now rarely (if ever) use InDesign to layout presentations, and I have started using Keynote almost exclusively for any web layouts I do.

Paul nennt 5 Argumente, warum er fast ausschließlich auf Keynote setzt. Erst beim Lesen des Artikel wurde mir klar, wie Recht er mit Argument 3 hat:

3. The cleverest grid lines I have ever met

It’s almost as if these lines can read my mind. I want equal space between these images? No problem. I want the centre point? Easy. I want these irregularly sized objects to all line up perfectly? Done.

(via Daring Fireball)

Legacy Code über Unittests verstehen lernen

Mon, 26 Mar 2012 16:12:00 GMT

Im Artikel Tips to Developers Starting on Large Applications beschreibt Choudary Kothapalli wie Unittests helfen, sich in unbekannten Code einzuarbeiten.

Find out if the application has any well maintained unit test cases. When available, unit test cases are a good way to understand large code bases. Unit tests help to start at the smallest pieces of the code base and to understand both the external interfaces of the unit

Unittests sind compilierbare Dokumentation. Im Gegensatz zu Textdokumenten passen sie stets zur aktuellen Codeversion. Wenn ich mich in Code einarbeiten muss - und sei es auch mein eigener, lange nicht mehr angefasster - so schaue ich mir zu aller erst die Unittests an. Sie verraten mir die API und zeigen, wie man sie nutzt.

Ein Überblick zum Robot Testing-Framwork

Sat, 24 Mar 2012 09:20:00 GMT

Für Acceptance-Test ist das Robot-Framework zur Zeit das Werkzeug meiner Wahl. Thomas Jaspers gibt in seinem Artikel Robot Framework Tutorial – Overview einen Überblick, der die Architektur und Ideen von Robot aufzeigt.

Wer braucht Agile Software-Entwicklungsprinzipien wirklich? Norwegen!

Thu, 22 Mar 2012 10:06:00 GMT

Norwegens Verwaltung erlaubt seinen Bürgern via Web-Software den Zugriff auf ihre Steuererklärungen. Nur blöd, wenn die Software ein Desaster ist:

Every single user who tried to log in went right past the login screen, and found themselves logged in as Kenneth, a 36 year old man from Oslo

Ich möchte nicht in der Haut der Entwicklungsfirma stecken, die für dieses Desaster verantwortlich zeichnet. Dieses Beispiel zeigt nicht nur, wie wichtig Agile Software-Entwicklungsprinzipien sind, sondern auch, dass ihre Missachtung die Zukunft ganzer Firmen und ihrer Mitarbeiter vernichten kann.

(via slashdot)

Tests drive development aus Sicht eines Golfers

Wed, 21 Mar 2012 12:32:00 GMT

Im zweiten Teil von Playing golf and Scrum macht Autor Krystian Kaczor eine besonders wichtige Feststellung:

TDD is a way of organizing architecture and code, not a testing technique, what is quite often misunderstood.

Genau! Tests treiben den Entwurf und die Entwicklung von Software an. Sie sind kein Add-on, das man am nach der Implementierung noch schnell programmiert. Ganz im Gegenteil sind Tests die compilierbare Spezifikation und Dokumentation unserer Software, die wirklich zählen; nicht irgendwelche UML-Diagramme oder Textdokumente.

Frei nach Uncle Bob:

Tests specify what your code does. Tests document how to use your code.

Buch: Functional Programming in Scala

Tue, 20 Mar 2012 21:03:00 GMT

Rúnar Bjarnason hat das Buch “Functional Programming in Scala” angekündigt. Rúnar ist im Scala Bereich bekannt für seinen Blog Apocalisp. Das Buch entsteht zusammen mit Tony Morris, der ebenfalls ein fester Bestandteil der Scala Community ist. Im kostenlosen Einleitungskapitel versprechen die beiden, das Buch würde allgemein von Funktionaler Programmierung handeln. Lediglich die Beispiele würden in Scala vorgestellt.

Ich freue mich auf das Buch und habe es bereits vorbestellt. Die Funktionale Programmierung gewinnt zunehmend an Fahrt und die beiden Autoren sind genau die richtigen, um an Hand von Scala in dieses Gebiet einzuführen.

Auf den Schwung konzentrieren: wenn Golfer Scrum anwenden

Tue, 20 Mar 2012 11:53:00 GMT

Krystian Kaczor schreibt aus der Sicht eines Golfers in “Playing golf and Scrum – Part I” über falsche Ziele beim Anwenden von Scrum:

The whole vision and purpose of doing Scrum is understood as getting as high Velocity as possible. In fact usually it is about getting the highest number as possible without looking at delivery.

Der Golfer Krystian rät:

Do not focus on the ball. Focus on the swing. The ball is only an indicator showing you how you have hit the ball.

Denn:

The goal of the Sprint is to deliver a Product Increment – working software that can be shipped to the customer. Not to have nice burndowns nor better Velocity.

Es gilt wie immer: "Der Weg ist das Ziel". Scrum ist keine Erfolgsmetrik, sondern ein Prozess, der uns hilft, unsere Entwicklungsarbeit im Team optimal auf die Kundenwünsche abzustimmen.

Chef vs. Puppet: Chef wins

Tue, 20 Mar 2012 09:40:00 GMT

Die Suche nach einem Configuration Management Werkzeug führt sehr schnell zu den Open-Source Projekten Puppet und Chef. Die Qual der Wahl zu Gunsten Chef hat Bryan Berrys Artikel “Puppet vs. Chef, Fight!” entschieden. Bryan erklärt praxisnah aus seiner Erfahrung, warum er sich für Chef entschieden hat:

In my humble opinion, Chef is technically superior. Don’t buy the argument “Chef requires you to be a programmer, Puppet doesn’t.” While Puppet is geared towards non-programmers, it becomes regular programming once you do anything moderately complicated. That’s when Puppet’s DSL becomes more of a liability than an asset and where Chef really shines.

Word ist kein Texteditor, oder doch?

Mon, 19 Mar 2012 15:38:00 GMT

Annie Lowery schreibt in ihrem Artikel “Where’s _why” über die Distanz zwischen Anwendern und Entwicklern. Dieser wird besonders deutlich, wenn ein Anwender versucht selbst ein Ruby Programm zu schreiben:

Second, I needed to figure out how to create and save a program—in my case, just a single line of text. I started off by saving it as a Word document, but it needed to be in plain text.

An diesem Beispiel wird offensichtlich, wie weit schon die Sprache zwischen Anwendern und Entwicklern auseinander klafft; Word? Ein Texteditor?

Im täglichen Umgang miteinander sollten wir stets im Auge behalten, dass Anwendern eben nicht klar ist, was für Entwicklern klar scheint.

★ Interview, oder Jochen Mais Überallbüro

Wed, 01 Dec 2010 09:21:00 GMT

**Im Interview gibt **Jochen Mai einen Einblick in seine Arbeitswelt. Er spricht über die Verbindung von Privat- und Arbeitsleben und welchen Einfluss neue Medien und Technologien auf seine Art zu arbeiten haben.

Jochen Mai ist Diplom-Volkswirt und Leiter des Ressorts „Management + Erfolg“ bei der WirtschaftsWoche. Anfang 2008 erschien sein Bestseller „Die Karriere-Bibel“ im Deutschen Taschenbuch Verlag (dtv). Das dazugehörige Online-Jobportal karrierebibel.de wurde im April 2009 mit dem „Lead-Award“ ausgezeichnet.

Das Interview

1. Der Job, oder was ist Dein Tätigkeitsbereich?

Ich bin Journalist, Autor und leite bei der WirtschaftsWoche seit gut neun Jahren das Ressort „Management&Erfolg“. Nebenbei betreibe ich mein Blog Karrierebibel, schreibe Bücher und halte Vorträge oder werde auf Podien eingeladen. Ich sehe das aber weniger als Job, sondern als Beruf. Ich muss meine Kreativität ausleben – und das tue ich beim Schreiben, beim Fotografieren, beim Malen oder Musizieren ebenso wie seit kurzem beim Filmemachen. Mein Beruf und meine diversen Aktivitäten geben mir die Chance, damit zu experimentieren sowie damit und daran zu wachsen.

2. Der Alltag, oder wie sieht Dein normaler Arbeitstag aus?

Aufstehen, Duschen, Frühstücken, dabei Feeds lesen und per Mail, Twitter, Facebook mit anderen kommunzieren, oft schon erste Blogartikel schreiben, ins Büro fahren, an Konferenzen teilnehmen, telefonieren, recherchieren, schreiben, publizieren, organisieren, planen, redigieren, bloggen, twittern, facebooken, nach Hause fahren und dort weiter kommunizieren.

3. Das Überallbüro, oder wie unterscheidet sich Dein Arbeitstag von früheren festen Büros?

Nicht viel. Ich habe ja noch immer ein Büro in der Readktion. Aber ich bin davon unabhängig. Im Grunde brauche ich nur mein Laptop, WLAN, Strom, Handy, Headset – und schon kann es losgehen.

4. Die Technik, oder welche Hardware und Software setzt Du ein?

So wenig wie möglich und so viel wie nötig. Seit kurzem besitze ich ein MacBook Pro und lerne gerade schwer von Microsoft auf die OS X Welt um. Ich nutze ein iPhone, und zum Skypen ab und an ein Headset von Sennheiser. Software: Skype, Firefox, Tweetdeck, Gimp, Final Cut, Word, Keynote – und diverse freie Programme sowie Add-Ons im Browser. Mein Blog basiert auf Wordpress.

5. Die Work-Life-Balance, oder wie hat sich Dein Leben durch die Arbeitsumstellung verändert?

Vorab: Ich mag den Begriff Work-Life-Balance nicht. Wenn ich arbeite, lebe ich auch. Und umgekehrt. Ich kann beim Schreiben wunderbar entspannen und manchmal ist es eben auch Qual. Fakt ist aber, dass durch das iPhone und die permanente Erreichbarkeit so etwas wie ein Feierabend kaum noch existiert. Eher ist es ein unterschiedlich organisiertes Abwechseln von Arbeits- und Freizeiten, von aktiven und Ruhephasen. Zu denen muss man sich aber bewusst entschließen. Vor kurzem habe ich dazu auch eine Titelgeschichte in der WirtschaftsWoche geschrieben, öfter sprichwörtlich abzuschalten, was ich auch selbst tue. Zeitgleich erschienen damals auch zwei Bücher mit demselben Tenor. Offenbar ist das ein Thema, dass auch andere umtreibt. Und ich bin sicher, dass nicht die Technik, sondern unsere Fähigkeit zum Selbstmanagement die eigentliche Herausforderung der mobilen Zukunft ist.

6. Dein Rat, oder was empfiehlst Du anderen, die noch nicht im Überallbüro arbeiten?

Finde heraus, ob diese Arbeitsweise zu dir passt. Probiere verschiedene Tools und Techniken aus – und vergiss nicht, dass es neben dem Online noch ein Offline gibt. Virtuelle Teams können noch so gut gesteuert sein – auf physische Treffen sollte keiner verzichten. Denn nur hier entstehen Vertrauen und die nötige Offenheit für spätere Diskussionen. Das ist sogar wissenschaftlich belegt (habe darüber schon gebloggt).

★ Urlaub, einfach mal nichts machen

Mon, 08 Nov 2010 10:39:00 GMT

Wenn man merkt, dass die eigene Leistungsfähigkeit nachlässt, ist die richtige Zeit für Erholung gekommen. Man sollte die Listen Listen sein lassen, Ziele zurückstellen und Aufgaben vertagen. Um sich richtig zu erholen, ist es wichtig, seinen Körper als auch seinen Geist entspannen zu lassen. Die gelingt nur, wenn man allen Druck und Stress beiseite schiebt und einfach mal nichts macht.

Ich nehme mir die kommenden Tage frei und werde einfach mal nichts tun. Deswegen erscheint der nächste Artikel im Dezember.

★ Blogparade, oder das schlaue Internet

Tue, 02 Nov 2010 18:20:00 GMT

Jochen Mai von Karrierebibel.de hat zur Blogparade gerufen — “Mach das Web zu einem schlaueren Ort!”. Er sucht Antworten auf die kuriosesten Suchanfragen, die zu meinem Blog geführt haben. Hier die Top 10:

Ziele und Aufgaben eines Baumarktes? — Ernsthaft?
Wie bekomme ich mein Gehirn wieder fit? — Der Anfang ist getan, Du hast den ersten Schritt gemacht.
*Versuche Gehirn — Genau, guter Ansatz!*
Spaß am Leben aber ziellos — Ich weiß nicht, ob das gut oder schlecht ist.
Arbeitsplanung Milchvieh — Ich wünschte ich könnte helfen, denke jedoch, dass die Tiere schon wissen was zu tun ist.
Homer Simpson Kuhmilch — Vielleicht weiß er mehr …
Ablenkung Schweinehund — Stimmt genau, bei Überallbüro.de bist Du richtig.
überall online Zeitverschwendung — Jedenfalls wird man den Schweinhund so nicht los.
Fokussieren Konzentratio Disziplin — Ja, das klappt wohl noch nicht ganz richtig.
Wie schalte ich Ablenkung aus? — Erste Schritt: Browser zu!

Weitere schlaue Antworten gibt es bei der Karrierebibel.

**
**

★ Letztes Jahr, oder die persönliche Überallzeitung

Tue, 02 Nov 2010 10:52:00 GMT

Letztes Jahr um diese Zeit beschrieb ich im Artikel “Instapaper, oder die persönliche Überallzeitung”, wie man mit Instapaper seine eigene Zeitung zum überall Lesen erstellen kann. Instapaper speichert per Knopfdruck aus jedem Browser die aktuelle Seite zum späteren Lesen. Dabei wird die Seite lesefreundlich umformatiert und von Werbung sowie anderen störenden Elementen befreit.

Schaut Euch den Artikel noch mal an, falls Ihr mehr wissen wollt.

★ Interview, oder Felix Govaers Organisation

Tue, 02 Nov 2010 10:33:00 GMT

Im Interview spricht Felix Govaers, Wissenschaftler bei der Frauenhofer Gesellschaft, über sein Organisationssystem. Insbesondere die ständige Fortentwicklung seines eigenen Systems und das kontinuierliche Hinterfragen alter sowie das Ausprobieren neuer Ansätze ist sein Erfolgsrezept für die persönliche Organisation.

Das Interview

1. Der Job, oder was ist Dein Tätigkeitsbereich?

In den vergangenen eineinhalb Jahren war ich als wissenschaftlicher Mitarbeiter, zur Hälfte an der Universität Bonn und zur Hälfte bei der Fraunhofer Gesellschaft eingestellt. Das war in Hinsicht auf die Organisation und Planung von Zeit und Aufgaben für mich eine beachtliche Herausforderung, da ich an beiden Instituten in Projekten mitgewirkt habe, bei einer Vorlesungsorganisation involviert war und an meiner Promotion gearbetet habe.

2. Die Herausforderung, oder was sind die wichtigsten Bereiche Deiner Planung?

Ich würde das mal salopp in Pflicht und Kür unterteilen. Die Pflicht sind selbstverständlich die obligatorischen Aufgaben, die in Projekten oder für Vorgesetzte anfallen. Weiter gehört dazu die zeitliche Planung, wann muss ich wo sein.

Die Kür ist die Organisation der restlichen Zeit. Das beinhaltet sowohl das Einplanen von langfristigen Aufgaben ohne akute Priorität, als auch das Energietanken durch Sachen, die mir Spaß machen. Der Punkt ist, dass man kreative Energie steuern, ja gar gezielt einsetzen kann und sollte. Gelingt mir das, dann macht die Arbeit großen Spaß.

Dazu gehört beispielsweise das Erstellen einer GUI. Meine Algorithmen brauchen so etwas nicht, aber es macht mir Spaß sie zu erstellen. Meist plane ich solche Spaßprojekte für 14 Uhr ein. Da ich mittags in die Kantine zum Essen gehe, bin ich ein Opfer des 14-Uhr-Tiefs. Ein Versuch anspruchsvolle Aufgaben zu diesem Zeitpunkt anzugehen würde mich nur frustrieren. Dennoch halte ich diese Lockerungsübungen optional. Je nach Gefühl setze ich sie ein oder setzte andere Aufgaben fort.

In derselben Art organisiere ich die Promotionsarbeit. Wenn über den Nachmittag hinaus noch Zeit ist, widme ich meine Konzentration dem Vorantreiben der Promotion. Allein das hehre Ziel gibt mir Motivation und damit neue Kraft.

3. Die Organisation, wie organisiert Du Dich?

Meine Termine landen über ein Outlook-Plugin oder über Apples iCal-Kalender direkt im Google-Kalender. Das ist für mich derzeit die einzige Chance, den Kalender überall und jederzeit verfügbar zu haben. Gelegentlich greife ich auch über mein Android-Telefon darauf zu. Allerdings ist dort die Bedienbarkeit noch recht mäßig, sodass ich es oft vorziehe, die Termine aufzuschreiben und dann zu übertragen. Denn das Touchpad des G1 hakt noch ein wenig und ist bei weitem nicht so präzise wie man das von der Konkurrenz kennt. Zudem ist die Struktur der Oberfläche dort noch nicht optimal gestaltet. Im Eifer des Gefechts habe ich bereits Termine versehentlich im falschen Monat eingetragen. Dann bin ich schließlich zum analogen System zurückgewandert. Für mein nächstes Android-Telefon habe ich viel Zuversicht, dass Google nachgelegt hat. Weiter ist die SMS-Erinnerungsfunktion von Google ist wie geschaffen für mich, da mein Telefon das einzige Gerät ist, das ich definitiv an beiden Arbeitsstellen bei mir habe.

Für Aufgaben habe ich einige Konzepte von Überallbüro.de übernommen. So verwalte ich die Liste meiner Aufgaben online mit RTM. Auch hier war wichtig, hardwareunabhängig darauf zugreifen zu können. Von dort aus plane ich Aufgaben für den nächsten Tag oder die aktuelle Woche ein. RTM schickt mir zusätzlich noch eine Email mit den Aufgaben für den Tag, die ich erst schließe, wenn alles erledigt oder neu eingeplant ist.

Taggs, Prioritäten und ähnlicher Schnickschnack bringen mir persönlich dabei nichts. Ich habe Aufgaben, und die werfe ich alle in einen Topf. Meine Verwendung von RTM ist also ziemlich die einfachst mögliche. Für meine Zwecke ist das jedoch völlig passend.

Ausgezeichnet finde ich es auch dort Ideen festzuhalten. Da jede Idee erst einmal ausgemalt und probiert werden muss, ist sie zugleich eine Aufgabe. Naturgemäß zunächst ohne Deadline. So gehe ich von Zeit zu Zeit über meinen Ideenstapel auf RTM, und wenn mich die Lust packt, greife ich eine auf.

Strukturen visualisiere ich in Mindmaps. Früher habe Vym genutzt, inzwischen gefällt mir XMind besser. Mit deinem Post-its-System machst Du im Prinzip nichts anders, nur analog.

In Treffen halte ich grundsätzlich den Verlauf in Stichworten fest. Hierfür habe ich mir Symbole überlegt, die mir beim Überfliegen das Wichtige hervorheben. Ein “!” zeigt mir z.B. eine Information an, während ein “X” ein ToDo-Icon darstellt. Diese markieren eingekreist die entsprechenden Zeilen meiner Stichworte. Weitere Symbole, die ich verwende sind ein „N“ für das nächste Folgetreffen, „D“ für eine Deadline und ein „?“ für etwas, das ich nachschlagen möchte. Diese Markierungen helfen nicht nur die richtigen Stellen schnell zu finden, sondern auch meine geschriebenen Textstücke am nächsten Tag wieder richtig zu interpretieren. Je nach Kontext, in dem wir uns befinden, interpretieren wir Informationen unterschiedlich. Symbole helfen mir quasi Missverständnisse mit mir selbst zu vermeiden.

4. Die Fehler, was läuft schief, wenn man sich organisieren will?

Ich empfinde es als die größte Herausforderung ein System zu finden und zu lernen, das für einen persönlich gut passt. Bei der Arbeit merke ich, dass sich meine Fehler in der Organisation wiederholen. Damit kann man offensichtlich auf ein unvollständiges System schließen, das meine Schwächen noch nicht wasserdicht abfängt. So lange sich Schwächen in der Organisation auftun, seien es Fehler oder redundante Arbeit, sollte man sein System überprüfen und Verbesserungsmöglichkeiten suchen. Zudem entwickelt man sich selbst über die Zeit weiter. Einerseits wird dabei vieles der täglichen Arbeit zur Routine, andererseits kommt mit der Zeit oft mehr zusammen. Die Mammutaufgabe schlechthin finde ich sowieso den Berufseinstieg (s. auch Interview mit Berufseinsteiger Jakob Bieling). Dort fehlen sowohl die Routine, als auch das Wissen um sinnvolle, ja mögliche Organisationstechniken überhaupt. Ein Student braucht für seine drei Prüfungen im Semester und seine Hilfskraftstelle keine systematische Organisation. Das ändert sich schlagartig mit dem Berufseinstieg. Meiner Ansicht nach könnten Arbeitgeber die Produktivität von Hochschulabgängern direkt steigern, indem sie zunächst Techniken, wie Du sie auf Ueberallbuero.de vorstellst, anlernen lassen.

Generell denke ich, man sollte alles mit dem Handy bedienen können. In meiner Organisation fehlen z.B. Möglichkeiten Informationen zu übertragen, wenn ich auf dem Handy Mails lese. Deadlines, Aufgaben und Termine können so im ungünstigsten Fall noch unter den Tisch fallen, da ich nichts in die entsprechenden Programme eintrage, die Mail jedoch als „gelesen“ ansehe.

5. Das System, oder welches System, Hardware, Software setzt Du ein?

Seit ich auf dem Mac arbeite, verwende ich die Standardwerkzeuge für Mails und Kalender von Apple. Auf meinem Handy läuft noch das recht frühe Android 1.5. Mein Google-Kalender ist auf dem Mac via Cal-DAV-URL eingebunden. Unter Windows binde ich ihn über das kostenlose „Google Calender Sync“ Tool in Outlook ein. Über den Erinnerungsdienst von Google werde ich an Termine jeweils mit einer SMS vorgewarnt. Aufgaben werden von Remember-the-Milk empfangen und sortiert, und auch die erinnern mich täglich mit einer Email an das Anstehende. Daten und Dokumente werden sicher und bequem per Dropbox auf verschiedene Systeme verteilt. Strukturen, Ideen und Brainstorming führen bei mir in Kombination immer zu einer Mindmap. Da finde ich alles, was ich kenne, gut. Zur Zeit benutze ich XMind wegen seiner Plattformunabhängigkeit. Für das Wenig, was jetzt noch übrig bleibt, muss Stift und Papier herhalten.

6. Dein Rat, was empfiehlst Du allen, die sich besser Organisation möchten?

Nun, dass sich jeder sein persönliches System erstellen muss, ist nichts Neues. Solange man nicht vollständig zufrieden damit ist, sollte man sich regelmäßig erkundigen was für neue Entwicklungen es gibt. Die Art und Weise, wie man Informationen handhabt, hat einen enormen Quantensprung hingelegt, seit Internet quasi überall verfügbar ist. Da lohnt es sich durchaus zu verfolgen, was Softwareentwickler daraus machen. Zudem ist es von großem Vorteil, wenn man einen Blog kennt, der darüber hinaus die sinnvolle Verwendung neuer Software zeigt, so wie Ueberallbuero.de.

★ Mikogo, oder im Schlafanzug arbeiten

Wed, 27 Oct 2010 14:27:00 GMT

Im heutigen Gastbeitrag stellt Maike das Online-Kollaborationsprogram Mikogo vor. Maike studiert BWL und arbeitet seit Sommer diesen Jahres für Mikogo. Sie zeigt konkret auf, wie man den Arbeitsplatz mit Desktop Sharing an den heimischen Schreibtisch verlegen kann. Und so auch von Business-Casual zum Pyjama wechseln.

Mikago, oder im Schlafanzug arbeiten

Dress Code hin oder her: Ich finde Business Kleidung unbequem. Blusen kneifen mich, Kostüme passen mir nicht, schicke Schuhe gefallen mir nicht. Ich mag Flanellschlafanzüge mit seltsamen Mustern und dicke Wollsocken. Zwar gibt es über solche Angelegenheiten keine Studien, aber ich bin mir sicher, dass Deutschlands Ich-würde-gerne-im-Schlafanzug-zur-Arbeit-gehen Fraktion nicht nur aus mir besteht. Ich behaupte sogar kühn, dass die Dunkelziffer extrem hoch ist. Wem es jedoch ein wenig an Mut fehlt, um im Morgenmantel mit dem Zug ins Büro zu fahren, dem bleibt nur eine Option: Das Home Office.

Ein Home Office hat jede Menge Vorteile. An die Stelle der langen Anfahrt ins Büro tritt der Gang ins Arbeitszimmer oder an den Schreibtisch. Doch ein Manko bleibt: die Kollegen und Kunden sind weit weg. Deswegen erfordert es eine effiziente Kommunikationstechnologie, mit der die Distanz überbrückt werden kann: Mikogo.

Mikogo ist ein Desktop Sharing Tool und simuliert genau jene Situationen, die im Großraumbüro an der Tagesordnung sind. Meetings, das Nebeneinander am Computer sitzen oder auch Verkaufspräsentationen. Anstelle des Konferenztisches tritt einfach das Internet. Indem es dein eigenen Bildschirminhalt an alle Sitzungsteilnehmer überträgt, können Dinge direkt am Monitor besprochen werden, ohne dass jemand den heimischen Schreibtisch verlassen muss (oder eben den Schlafanzug gegen den Business Look tauschen).

Sitzungsstart

Um eine Mikogo Session zu starten, braucht es lediglich 3 Klicks. Der Sitzungsorganisator wählt einfach im System Tray das M-Icon aus und wählt dann im Menü „Start Session“. Der Mikogo Server generiert daraufhin eine Session-ID, die an die anderen Teilnehmer weitergegeben wird. Bis zu 10 Personen können gleichzeitig an einem Online Meeting partizipieren, eine installierte Version von Mikogo braucht dabei nur der Organisator. Die anderen betreten den virtuellen Konferenzraum durch einen Klick auf den Teilnehmen Button auf der Mikogo-Website, geben die Sitzungsnummer ein und sehen dann sofort in Echtzeit den Bildschirminhalt des Organisators.

Funktionen

Mikogo bringt eine Reihe von Funktionen mit sich, bei denen insbesondere die Switch-Presenter-Option, Zeigepfeil, Whiteboard und der Session Recorder im Home Office Alltag von Nutzen sind.

Switch Presenter: Jeder Teilnehmer kann während der Sitzung zum Presenter ernannt werden. Nach dessen Zustimmung ist dann für alle dann dessen Bildschirminhalt zu sehen.

Zeigepfeil und Whiteboard: Durch einen Klick auf eine Stelle im Mikogo-Fenster erscheint für alle ein Pfeilsymbol mit dem zugehörigen Namen des Teilnehmers. Mit dem Whiteboard können wie mit dem klassischen Textmarker bestimmte Bereiche bunt markiert werden.

Session Recorder: Mikogo bietet die Möglichkeit, jede Session zu protokollieren und im Nachhinein mit dem Session Player wiederzugeben. Einen Überblick über weitere Funktionen gibt es hier.

Um im Arbeitsalltag auch bei sensiblen Daten die größte Sicherheit zu gewährleisten, arbeitet die Software mit einer 256-Bit-AES Verschlüsselung.

Versionen

Mikogo steht als Mac- und PC-Version unter www.mikogo.de zum Download bereit und ermöglicht dank Plattformunabhängigkeit auch die Kommunikation zwischen den beiden Betriebsystemen. Die Nutzung von Mikogo ist nicht nur für private Nutzer, sondern auch im kommerziellen Bereich kostenlos.

Verwandte Artikel:

TeamViewer, oder das digitale Fernrohr

★ Letztes Jahr, oder Arbeitsplanung

Mon, 18 Oct 2010 10:53:00 GMT

Letztes Jahr um diese Zeit beschrieb ich im Artikel “Arbeitsplanung, oder das Was und Wann”, wie ich meine Aufgaben und Zeit plane. Mit Hilfe von Remember The Milk und einem Kalender halte ich meine Aufgaben fest und wähle die Zeiten aus, wann ich mich an die Aufgaben setze.

Dieser Artikel war die Einleitung zu einer dreiteiligen Serie und gab eine Übersicht über mein Organisationssystem, das ich auch heute kaum verändert erfolgreich einsetze.

Schaut Euch den Artikel noch mal an, falls Ihr mehr wissen wollt.

★ Listenlos, oder arbeiten wie ein Meisterkoch

Mon, 11 Oct 2010 07:57:00 GMT

Das Dreyfus-Modell (engl., PDF von Jörg Markowitsch) beschreibt den Wissensstands einer Person in 5 Stufen. Während sich ein Novize buchstabengetreu an Anleitungen hält, agiert ein Experte in meist nach dem Gefühl, seiner Intuition folgend.

Ein Kochlehrling hat Schwierigkeiten mit der Anweisung einen Teelöffel Salz zur Suppe zu geben. Er stellt sich die Frage, welche Art Teelöffel und ob dieser gehäuft oder glatt gestrichen sein soll. Ein Meisterkoch hingeben schmeckt die Suppe ab und gibt eine Priese Salz dazu ohne über Maßeinheiten und Mengen nachzudenken. Seinem Gefühl folgend, passt es einfach.

Mein persönliches Organisationssystem

Nachdem ich erkannt hatte, dass ich meine Arbeit besser organisieren sollte, begann meine Suche nach dem passenden Organisationssystem. Egal welches ich ausprobierte, mangels Erfahrung folgte ich blind den entsprechenden Regeln und Tipps. Dabei dienten mir Listen als Erinnerung an zu erledigende Aufgaben, Zeitabschätzungen der Arbeitsplanung sowie ihre Abarbeitung als Kontrolle und Fokussierungshilfe.

Dieser Ansatz ist zu Beginn für den Novizen sinnvoll und richtig. Mit der Zeit änderte sich aber meine innere Einstellung. Was früher nur mit harten Regeln funktionierte, entwickelte sich zu Gewohnheiten, zu Automatismen. Während die Listen zu Beginn Halt und Kontrolle gaben, kam mit der Zeit eine natürliche Arbeitseinstellung dazu.

Mir war plötzlich viel klarer was meine Ziele sind, welche Schritte im jeweiligen Projekt zu erledigen sind und es fiel mir leichter, die Konzentration und Fokussierung auf die Arbeit zu finden.

Meine Listen

Mir ist vor einiger Zeit aufgefallen, dass meine Listen immer kürzer werden. Daraufhin habe ich mich gefragt, ob ich meinem Organisationssystem noch richtig folge oder ob ich es schleifen lasse. Dabei wurde mir klar, dass Listen für mich nur noch für das Festhalten von Ideen und Gedanken sowie als Erinnerungshilfen für kleinen Besorgungen dienen. Ich setze sie als Braindump ein, um meinen Kopf von Kleinigkeiten freizuhalten. Das tägliche Entlanghangeln an Listen, von Aufgabe zu Aufgabe also die Kontrollfunktion von Aufgabenlisten ist für mich entbehrlich geworden.

Meine Zukunft

Ich weiß nicht genau, wie diese Entwicklung weiter gehen wird. Der natürliche Weg scheint, nur noch Ideen und Gedanken festzuhalten, da sich alles andere durch die persönlichen Gewohnheiten erledigt.

Dein Fazit

Entscheidend ist mit der persönlichen Entwicklung auch das eigene Organisationssystem weiter zu entwickeln. Im Interview beschreibt Jakob Bieling genau diese Entwicklung, wie er von festen Regeln zu seiner eigenen Methode gefunden hat.

Macht Dir also klar, in welcher Entwicklungsstufe sich Du und Dein Organisationssystem befinden. Es ist wichtig, nicht sklavisch Büchern, Regeln und Tipps zu folgen, sondern selbstständig zu entscheiden, wie viel Organisation nötig und wie viel übertrieben ist.

Deine Meinung

Welche Erfahrung hast mit Deiner Entwicklung gemacht? Ich bin sehr gespannt auf Deine Perspektive und Erfahrungen.

Verwandte Artikel:

★ Letztes Jahr, oder Teamviewer

Sun, 03 Oct 2010 10:57:00 GMT

Letztes Jahr um diese Zeit beschrieb ich im Artikel “TeamViewer, oder das digitale Fernrohr” wie man über das Internet einen entfernten Computer bedienen kann, ohne wirklich davor sitzen zu müssen. Ob Fernwartung, Präsentation oder das Kopieren von Daten — mit Teamviewer holt man Bildschirm, Tastatur und Maus von einem auf den anderen Computer. Für den privaten Einsatz ist Teamviewer kostenlos.

Schaut Euch den Artikel noch mal an, falls Ihr mehr wissen wollt.

★ Interview, oder Franz Hoffmanns Überallbüro in Afrika

Fri, 01 Oct 2010 07:35:00 GMT

Dieses Mal im Interview beschreibt Franz Hoffmann sein Überallbüro in Bamako, Mali, West Afrika. Franz hat die Loslösung von einem festen Arbeitsplatz vollständig erreicht, denn seine Kollegen arbeiten in Deutschland und seine Kunden sind weltweit verteilt. Er zeigt auf eindrucksvolle Weise, wie man mit den richtigen Werkzeugen und dem passenden System überall und jederzeit arbeiten kann und dadruch an einem wunderschönen Ort sein Leben genießen kann. Insbesondere die Loslösung vom normalen Arbeitstrott hat Franz eine ganz neue Perspektive und mehr Zeit für sich und seine Leben gegeben.

Franz Hoffmann ist Produktdesigner und Geschäftsführer von Leschi www.leschi.de. Gemeinsam mit seinen Mitarbeiten und Partnern liefert er Wärme-, Nacken- und Kuschelkissen sowie andere Wohlfühlaccessoires in weltweit 30 Länder. Zusätzlich zu seiner Arbeit studiert Franz erfolgreich BWL an der Fernuniversität Hagen und ist somit für Prüfungen des öfteren Gast der Deutschen Botschaft in Bamako.

Das Interview

Der Job, oder was ist Dein Tätigkeitsbereich?

Als Produktdesigner und Geschäftsführer meines eigenen Labels bin ich mit drei Kernbereichen beschäftigt, Design sowie Produktentwicklung, Key-Account-Management und Führung. Unser Sortiment besteht aus freundlichen, kuscheligen Produkten, die rund ums Sofa verwendet werden, der Schwerpunkt liegt auf Wärmekissen. Für die Produkte entwerfe ich die Formen und Schnittmuster und übergebe sie der Produktion. Meine Kunden, meist im Ausland, betreue ich per Telefon und E-Mail, empfehle Sortimente und bereite gemeinsame Marketingaktionen vor. Jeweils zum Frühjahr und zum Herbst wird die neue Kollektion auf Messen in Europa präsentiert zu denen ich persönlich anreise. Dazu kommen die Führungstätigkeiten wie beispielsweise strategische Analysen, taktische Kontrolle und Personalführung, die dann in klassische Managementaufgaben mündet.

Der Alltag, oder wie sieht Dein normaler Arbeitstag aus?

Der erste Griff am Morgen schaltet die USV ein, der Router fängt an zu blinken und die Internetverbindung wird aufgebaut. Dann greife ich meinen Rucksack, den Bürostuhl und ein Glas frisch gepressten Orangensaft und klettere über die Holzleiter aufs Flachdach. Je nach Sonnenstand rücke ich meinen Schreibtisch in den Schatten der Mangobäume an der linken oder rechten Hausseite. Dann lese ich E-Mails und schaue in den Operationsplan für den Tag.

Die Meetings laufen per Skype. Einer der Teilnehmer übernimmt die Moderation des Meetings, was aufgrund der recht hohen Latenzzeit wichtig ist. Durch die Entfernung benötigt die Stimme lange um hin- und herzureisen, das führt ohne Ordnung häufig dazu, dass man sich ins Wort fällt.

Das Nebeneinandersitzen und gemeinsame Bearbeiten von Dateien simulieren wir durch Desktop-Sharing. Dabei übermittelt ein Teilnehmer den Inhalt seines Bildschirms, man schaut praktisch auf den gleichen Monitor. Das ist für gemeinsame Planungen an Exceltabellen und Brainstormings anhand von Mindmaps essentiell. Zusammen mit der meist hervorragenden Sprachqualität von Skype hat man fast das Gefühl beieinander zu sein.

Nach dem ersten Glas O-Saft sind die Kunden dran. Ich betreue den Großteil der Export-Kunden. Das läuft von Ost nach West ab. Erst sind die Japaner und Australier dran, da sie meist noch arbeiten, wenn ich aufstehe, und mittags die Europäer.

Drei Autominuten entfernt hat Alpha, ein Schneider aus dem Senegal, in einem winzigen Raum fünf Nähmaschinen aufgestellt und fertigt Hochzeitskleidung. Eine seiner uralten Nähmaschinen kommt zufälligerweise aus Berlin. Benötige ich einen Prototypen, stürme ich mit den Schnittmustern in den Laden, tausche die neuesten Champions-League-Ergebnisse aus und Alpha stellt mir einen seiner Jungs ab, der mit erstaunlicher Akribie meine Vorgaben umsetzt. Bis heute habe ich nicht verstanden, woraus ihre Motivation für diesen tollen und prompten Service entspringt. Ich vermute aber, dass sie es selbst spannend finden, die merkwürdigen Designs dieses noch merkwürdigeren Deutschen umzusetzen. Vielleicht ist es aber nur die Freude daran eine völlig absurde Tätigkeit zu verrichten: Wärmekissen nähen bei 42 °C im Schatten.

Diese Prototypen bespreche ich anschließend mit meinen Partnern in Berlin. Das Produkt wird vor der Skype-Kamera gedreht und gewendet und Änderungsschritte definiert, die Alphas Jungs später umsetzen. Ist meine Arbeit abgeschlossen, geht das Schnittmuster an unseren Qualitätsmanager, der die Umsetzung durch die Produktionsstätte in Polen einleitet. Wiederum werden Prototypen erstellt und diesmal in Europa vor die Kamera gehalten. Dass das Dreieck Mali – Polen – Deutschland so gut funktionieren würde, hatten wir vorher nicht gedacht. Ursprünglich war vorgesehen, dass ich für die Produktentwicklung nach Deutschland zurückkomme.

Das Mittagessen koche ich zu Hause, da die malischen Straßenimbisse selbst für einen rustikalen Berliner eine Herausforderung darstellen. Mit dem Teller Nudeln klettere ich wieder aufs Dach und entspanne vor der Tagesschau – ein Stück Heimat!

Der Nachmittag ist meist längeren Arbeitstreffen vorbehalten. Wieder per Desktop-Sharing und Skype. Die Bandbreite reicht momentan leider nicht dafür, auch noch das Video bei Skype anzuschalten, aber vor kurzem wurde UMTS in Bamako eingerichtet und das lässt hoffen.

Das Überallbüro, oder wie unterscheidet sich Dein Arbeitstag zum festen Büro in Deutschland?

Für mich ist die Kommunikation der Hauptpunkt und der wichtigste Unterschied; zu Kunden, zu Lieferanten, zu Partnern und zu Kollegen im Büro. Denn erst wenn ich kommunizieren will, fallen die 5.000 km Distanz ins Gewicht. Vorher ist es egal, ob ich das Schnittmuster in Berlin oder in Bamako erstellt habe. Will ich es aber besprechen und mir ein Feedback einholen, muss ich kommunizieren. Die Technik ist für mich essentiell und so verwende ich wesentlich mehr Zeit und Gedanken an die Infrastruktur als in Berlin. Das nervt und macht die Fokussierung auf die eigentlichen Aufgaben mitunter schwierig.

Durch die räumliche Distanz zu den Partnern bin ich mehr auf mich allein gestellt und durch meine Abwesenheit ging das den Partnern im Berliner Büro genauso. Das führte überraschenderweise schon ab dem ersten Tag dazu, dass alle fokussierter waren, Meetings besser vorbereitet wurden und mehr individuelle Verantwortung übernommen wurde. Vorher hätte man sagen können, dass wir zu häufig über zu viel unwichtiges Zeug sprachen, das man auch allein hätte entscheiden können. Ein deutlicher Pluspunkt!

Zudem bin ich erheblich weniger Störungen ausgesetzt als im lauten Berliner Großraumbüro. Ich kann die Aufgaben nach meinem Rhythmus durchziehen, und auch die größte Hektik kommt nur abgemildert bei mir an. Insgesamt benötige ich weniger Zeit für die gleiche Menge an Ergebnis. Gänzlich unterbrechungsfrei läuft aber auch mein Tag in Mali nicht ab, mitten in einem Gruppen-Meeting schaute einmal ein Tuareg-Krieger auf seinem Kamel über die Mauer und erwartete einen Beitrag zu seinem Reiseproviant.

Inzwischen merke ich gelegentlich, dass ich Lust auf etwas Gesellschaft hätte, um dem Gefühl zu entgehen, ich sei gänzlich von der Außenwelt abgeschnitten. Noch in Deutschland planten wir eine dauerhafte Video-Übertragung zwischen den beiden Büros einzurichten. Das scheiterte bislang an der technischen Umsetzung. Wem eine praktische Software für die dauerhafte Bild- und Tonübertragung im Stil einer Überwachungskamera einfällt, bitte melden. Man muss auch die Bildfrequenz bzw. –qualität einstellen können, um sich an die afrikanischen Bandbreiten anzupassen.

Die Tests – die klappten wenigstens – zeigten aber schon mal, dass man durchaus die Anwesenheit anderer Personen darüber simulieren kann. Es erzeugte für mich schon mal ein Wir-Gefühl und ein: „auch andere, nicht-virtuelle Menschen arbeiten an der gleichen Geschichte wie du“.

Das Leben, oder wie ist das Privatleben in Mali?

Der wohl deutlichste Unterschied besteht in den realen Sozialkontakten. Ich verbringe die meiste Zeit im bzw. auf dem Haus und lebe in dieser Zeit an einem völlig anderen Ort, in einer eigenen Zeitzone, mit völlig anderen Menschen. Wenn der Computer aus ist, blicke ich manchmal nach draußen und frage mich: wo bin ich? Es dauert aber nicht lange, bis ich von der einen Realität zu anderen wechseln kann. Dann fällt mir schnell auf, dass ich in Afrika bin und Bamako eine abgedrehte, dreckige, laute, übervolle, afrikanische Stadt ist, die darauf wartet erkundet zu werden. Es ist, also ob ich von der Arbeit direkt in den Urlaub starte. Es gibt keinen Alltag. Wenn ich Deutschland Schwierigkeiten hatte von der Arbeit abzuschalten, dann gelingt mir das in Bamako auf Knopfdruck. Rechner aus, Tür auf und das Leben schwappt herein.

Am liebsten fahre ich am Abend mit meiner Frau an den von Mangobäumen umrahmten Pool des kleinen und ein bisschen schäbigen Hotels Eden-Village, direkt am Niger. Allein der Weg dahin ist so unglaublich anders als in Deutschland. Selbst nach einem Jahr fühlt es sich so neu und fremd an. Das ist ein wahrer Traum!

Wenn ich aber zwei Tage am Stück selbst abends nicht das Haus verlassen habe, fällt mir die Decke auf den Kopf und ich muss dringend reale Freunde treffen. Diese sind noch nicht so zahlreich und wenn keiner Zeit hat, texte ich den Bäcker, Tankwart oder den Äpfelverkäufer mit belanglosem Zeug zu, um ein bisschen unter Leute zu kommen. In Berlin lief das von allein, da war immer einer am Start.

Die Technik, oder welche Hardware und Software setzt Du ein?

2 Windows-Laptops, 1 Windows-Netbook, 1 Apple-Laptop, Dual WAN-Router [Draytek Vigor 2910, sehr solide](zum Anschließen von zwei Internetanschlüssen), 1 Interanschluss mit 386 kbit und 1 mit 256 kbit (tagsüber zu Spitzenzeiten meist nicht voll verfügbar), Extra-Akku für den Hauptlaptop, USV mit Batterielaufzeit bei Stromausfällen bis zu 3 Stunden, 22‘‘-Monitor, kleiner HP-Laserjet mit 2 Tonern auf Reserve, jeweils mehrfache Ausführung von Maus, Headset [Sennheiser PC-31 sehr zu empfehlen, günstig und gut], Tastatur und 1 Million Kabel. Dazu noch 3 Backup-Festplatten, Allwetter-Bambus-Schreibtisch auf dem Dach, USB-Tastatur-Staubsauger gegen Wüstenstaub, USB-Ventilator (für den Prozessor) und extrem wichtig, die Klimaanlage ohne deren Einsatz kein Hirn in der heißen Zeit arbeiten kann.

Es ist ein Ensemble mit Netz und doppeltem Boden, das ich nicht nur rein praktisch, sondern auch für den Seelenfrieden benötige. Wenn ein wichtiges Kundengespräch ansteht, muss alles funktionieren - auf die Minute genau. Das sind Anforderungen, die völlig konträr zum malischen Alltag sind und mir die zwei Welten, in denen ich lebe deutlich vor Augen führen.

Bei Stromausfällen von über 3 Stunden, wenn die USV leer ist, ziehe ich ins Hotel um. Mit Generator im Keller und Internet in der Lobby, das außer mir kaum einer nutzt, ist das eine gute Alternative. Das kommt etwa 1-2 mal im Monat vor. Die Standortverlagerung führt mitunter sogar zu neuem Schwung und einer Abwechslung. Bonus ist der Hotelpool, der ebenfalls kaum von anderen Gästen genutzt wird.

Dein Rat, oder was empfiehlst Du anderen, die noch nicht im Überallbüro arbeiten?

Zusammen mit meinen Partnern habe ich die Firmenstruktur so umgebaut, dass Platz für persönlichen Freiraum entsteht. Das erschien uns zuerst völlig utopisch und sogar gefährlich für das Business. Aber rückblickend waren die Hürden nicht so hoch wie eingangs erwartet. Gerade in Kreativberufen ist mentale Freiheit und Ausgeglichenheit sehr wichtig für gute Resultate und das ist Grund genug ein Risiko einzugehen.

Ich denke, dass der schwierigste Schritt der ist, sich das Arbeiten außerhalb eines klassischen Büros vorzustellen. Worauf kommt es wirklich an bei meiner Tätigkeit? Wann produziere ich Resultate und wann verbringe ich nur Arbeitszeit? Hat man diese Frage für sich und seinen Beruf geklärt, entdeckt man vielleicht Freiräume an Stellen, die man vorher nicht sah.

★ Ziellos, oder der Weg ist das Ziel

Mon, 27 Sep 2010 07:59:00 GMT

http://ueberallbuero.de/wp-content/uploads/2010/09/Spass_auf_dem_Weg.jpg

“Nur wer sein Ziel kennt, findet den Weg”, so Laozi der Begründer des Taoismus. Nur wenn wir unser Ziel klar vor Augen haben, können wir den Weg dorthin in lösbare Teilaufgaben aufteilen. Und nur dann können wir unsere Projekte erfolgreich abschließen.

Der Weg ist das Ziel

Das Setzen von Zielen zieht konsequenterweise das Messen von Fortschritt nach sich. Nur mit messbaren Teilergebnissen kann ich kontrollieren, ob ich auf dem richtigen Weg zu meinem Ziel bin. Jedoch gibt es Wege, die kein Ziel haben, so wie es bei Reisen nicht immer ums Ankommen, sondern ums Unterwegssein geht. Entspannung, körperliche Fitness, gesunde Ernährung, Spaß in der Freizeit lassen sich kaum messen oder konkreten Zielen zuordnen, jedoch sind sie wichtige Bestandteile eines erfüllten, glücklichen Lebens.

Am Anfang braucht man Kontrolle

Natürlich ist es sinnvoll, zu Beginn eines neuen Weges die ersten Schritte vor Augen zu haben. Insbesondere wenn dieser Weg außerhalb der täglichen, routinemäßigen Pfade liegt, helfen Ziele und Teilschritte, sich wirklich aufzumachen. Es ist sinnvoll, in seine Tagesliste Zeit für Entspannung einzuplanen, in seinen Kalender 2x wöchentlich den Fitnessclub einzutragen und im Wochenplan höchstens eine Curry-Wurst zu erlauben. Nur so gelingt es, Gewohnheiten zu ändern indem man Schritt für Schritt an sich arbeitet.

Ohne Druck

Mittel- und langfristig geht es aber nicht um Arbeit. Es geht darum, seine Persönlichkeit weiterzuentwickeln. Dabei können Listen und Kontrolle kontraproduktiv werden. Sie erzeugen Druck mehr zu tun, besser sein zu müssen, so dass man aus den Augen verliert worum es wirklich geht.

Ich gehe in die Sauna, um für mich zu sein, zur Ruhe zu kommen. Ich klettere an Wänden herauf, weil mir es Spaß macht, weil der Sport mir ein besseres Lebensgefühlt gibt. Ich ernähre mich gesund, weil mir das Essen besser schmeckt und meine Lebensqualität dadurch steigt. Nicht die Sanduhr in der Sauna entscheidet, wie lange ich bleibe, sondern ich gehe, wenn ich wenn ich soweit bin. Nicht die Fitnessverrückheit der Nation zwingt mich in den Fitnessclub, sondern der Spaß an der Bewegung. Nicht die Hippness von Bio-Ernährung, sondern der bessere Geschmack und die Freude an gutem Essen entscheiden darüber, was ich essen. All dies tue ich nicht um ein Ziel zu erreichen, um einen Punkt auf meiner Todo-Liste durchzustreichen, sondern weil es mich erfüllt.

Ziele oder keine Ziele?

Man braucht klare Ziele, um den Weg zu finden, sie zu erreichen. Aber vergesst bei aller Zielstrebigkeit nicht, dass ihr auch Ruhe und Entspannungsphasen braucht, dass ihr Spaß und Freunde in Eurem Leben haben müsst. Und dies erreicht man nicht mit Listen und messbaren Teilschritten.

Verwandte Artikel:

★ E-Mail-Footer, oder willkommen im Jahr 2010

Mon, 13 Sep 2010 07:39:00 GMT

Sinnvolle und zeitgemäße E-Mail-Footer erstellen mit WiseStamp.com.

Verwandte Artikel:

E-Mails, oder willkommen im Jahr 2009

★ Scrappad, oder die Notizen des Tages

Mon, 06 Sep 2010 09:17:00 GMT

Von freien Gedanken und dem assoziativen Teil unseres Gehirns habe ich im Artikel “Post-its, oder die freien Gedanken festhalten” berichtet. Die freien Assoziationen sind dafür verantwortlich, dass wir Ideen nicht linear entwickeln, sondern unser Gehirn von einem Gedanken zum anderen springt. Die wichtigste Konsequenz daraus ist, sich nicht zu linearem Denken zu zwingen, sondern Gedanken festzuhalten und später geordnet zu verbinden.

Unser Gehirn produziert jedoch nicht nur Ideen zum aktuellen Fokus, also zur Frage, mit der wir uns gerade aktiv beschäftigen. Es findet parallel auch neue Ansätze zu Fragen, die noch im Hintergrund offen stehen. Jeder, der eine Melodie im Radio hört, aber erst Minuten später auf den Titel kommt, erlebt gerade die Arbeit unseres Gehirns an einer Hintergrundaufgabe in Aktion. Auch diese Gedanken und Ideen sollten wir festhalten.

Analog und Digital

Wir sind mit dem handschriftlichem Festhalten unserer Gedanken aufgewachsen. Schon vor dem Kindergarten malen wir, was sich in unseren Köpfen abspielt. Aus diesem Grund, ist das analoge Festhalten unschlagbar schnell und fällt uns so leicht.

Zu Beginn des Tages, klebe ich mir deshalb ein leeres Post-It auf den Tisch und schreibe das aktuelle Datum darauf — das Post-It des Tages. Wann immer mir bei der Arbeit eine Idee kommt, ich mich an etwas erinnere oder ich eine neue Aufgabe bekomme, halte ich sie darauf fest; schnell und ohne mich von meiner derzeitigen Aufgabe ablenken zu lassen. Im Post-Its Artikel kann man das im zweiten Bild sehen; es sind schon zwei für diesen Tag, lila, direkt über dem Buch.

Zusätzlich zum Post-It halte ich den ganzen Tag eine Evernote-Notiz offen; jeden Tag eine neue mit dem Titel “Scrappad <Datum des Tages>” — das Scrappad des Tages. In diese Notiz lege ich alles digitale des Tages ab, das ich vielleicht noch einmal gebrauchen könnte: Ergebnisse aus der Zwischenablage, Änderungen von Dokumenten, Programmierschnipsel und Internet-Recherchen.
Wer kennt das nicht, man benötigt das Ergebnis einer Google-Suche gleich noch mal, nachdem man das Browser-Fenster geschlossen hat.

Am Ende des Tages

Bevor ich meinen Arbeitstag beende, gehe ich diese Notizen des Tages abschließend durch. Dabei entscheide ich, welche ich verwerfe und welche ich vielleicht noch einmal gebrauchen könnte. Alle was relevant scheint, trage ich als neue Aufgabe in Remember the Milk, als neue Information in Evernote bzw. mein Logbuch oder wohin es sonst in mein Organisationssystem gehört ein.

Versucht es selbst und startet den nächsten Arbeitstag vorbereitet für Ideen und Erkenntnisse, die auf den ersten Blick zufällig oder unwichtig erscheinen, und haltet sie fest. Wer weiß, wann ihr sie gebrauchen könnt.

Verwandte Artikel:

★ Interview, oder Jakob Bielings Organisation

Wed, 01 Sep 2010 07:45:00 GMT

Im heutigen Interview berichtet Dipl.-Inform. Jakob Bieling von seinen Erfahrungen im ersten Arbeitsjahr nach der Uni. Er geht dabei auf die organisatorischen Herausforderungen ein, die sich durch den Eintritt ins Arbeitsleben ergeben und wie er mit diesen umgegangen ist. Detailliert beschreibt Jakob, wie er sein eignes Organisationssystem entwickelt hat, denn nur ein persönliches System kann auch wirklich funktionieren. Ganz besonders wichtig war ihm dabei, dass alle Informationen an genau einem Ort abgelegt und wiedergefunden werden können.

Jakob arbeitet zur Zeit als wissenschaftlicher Mitarbeiter an der Universität Bonn und promoviert im Fach Informatik.

Das Interview

Der Job, oder was ist Dein Tätigkeitsbereich?

Nach dem Studium habe ich mich entschlossen weiterhin an der Universität zu bleiben. Zum einen halte ich dort vorlesungsbegleitende Tutorien und zum anderen, was den größeren Teil der Arbeitszeit ausmacht, arbeite ich in Projekten für verschiedene Firmen und Institutionen mit.

Die Veränderung, oder was sind die Herausforderungen am Anfang?

Die wohl größte Veränderung liegt in der Zeit, die einem für die alltäglichen Dinge zur Verfügung steht. Während des Studiums hat man einmal die Woche eingekauft, alle paar Wochen die Wäsche gewaschen und noch zugesehen, dass man die Übungszettel für die Klausurzulassung gelöst hat. Hier hat man sich mehr oder weniger reingehängt, je nach dem wie es einen interessiert hat. Den Rest der (zugegebenermaßen recht üppigen) Freizeit hat man dann mit Sachen verbracht, die einen gerade interessierten. Sei es Programmieren, sich sportlich betätigen oder gemeinsam mit Freunden etwas unternehmen. Termine gab es im Prinzip keine, abgesehen von den wöchentlich festen Vorlesungs- und Übungszeiten. Diese hatte man dann auch ohne Terminplaner immer recht gut im Kopf.

Mit einer Vollzeitbeschäftigung wurde das natürlich alles anders. Man wusste es vorher gar nicht richtig zu schätzen: von dem Tag bleibt nun nicht mehr so viel Zeit übrig, so dass man sich schon ganz genau überlegt, was man damit anstellt. Dass hierbei manche Aktivitäten etwas eingeschränkt werden müssen, versteht sich dann fast schon von selbst. Projekte, die man eher aus Spaß verfolgt hat, fallen hier zuerst aus dem Zeitplan. Aber selbst sinnvolle Vorhaben, wie zum Beispiel das Anbringen einer ordentlichen Deckenlampe, schiebt man aus Zeitmangel schon eher vor sich her. Hinzu kommt, dass es weitaus mehr Dinge gibt, an die man denken muss. Zudem sind das dann meist Termine, die sich nicht in mehr oder minder festen Intervallen wiederholten. Denn solche ließen sich ritualsmäßig meist in den Tages- und Wochenablauf einbauen. Bei Treffen mit Studenten funktioniert das hingegen nicht. Durch diese neue Vielzahl an Terminen wird ein Organisationssystem notwendig, das mir zum einen einen Überblick über meine Termine verschafft, um keine Terminkonflikte entstehen zu lassen. Zum anderen steht aber natürlich die Erinnerung an diese Termine im Vordergrund. Ein Terminplaner aus Papier, den ich stets bei mir tragen würde, erfüllt demnach nur die Hälfte meiner Anforderungen.

Die Organisation, oder was sind die wichtigsten Bereiche Deiner Planung?

Die Planung ist im Grunde sehr simpel. Am wichtigsten ist es, dass ich immer Zugriff auf meine Termine, ToDos und Notizen habe; sowohl, um stets neue Termine etc. hinzuzufügen, als auch, um an eben solche erinnert zu werden.

Die Fehler, was läuft am Anfang schief, wenn man sich organisieren will?

Natürlich ist man selbst eine Fehlerquelle. Versucht man sich in ein neues Organisationssystem einzufinden, fällt das anfangs schwer. Doch hat man sich erst einmal daran gewöhnt, Termine und Notizen so abzulegen, dass man später erinnert wird bzw. weiß, wo man nachschauen muss, merkt man auch, dass das System funktioniert.

Es kommt jedoch erschwerend hinzu, dass es neben dem konventionellen Terminplaner aus Papier auch unzählige Programme gibt, die einem dabei helfen wollen, sich zu organisieren. Things, OmniFocus, Remember the Milk, Evernote sind nur einige davon, jedes mit seinem mehr oder weniger weiten Anwendungsgebiet. Hier muss man sich zunächst diejenigen Anwendungen herauspicken, die einen selbst am besten unterstützen. Ich musste feststellen, dass es nicht ausreicht, Empfehlungen anderer Leute zu lesen. Man muss es selbst ausprobieren und schauen, ob es zu einem passt. Das kann mitunter sehr lange dauern. So stehe ich nun ein Jahr nach dem Einstieg ins Arbeitsleben an dem Punkt, dass ich weiss, welche Tools ich benutzen möchte. Die Eingewöhnung ist jedoch noch im Gange.

Das System, oder welches System, Hardware, Software setzt Du ein?

Meine Organisation stützt sich auf drei Programme: Evernote, Things und iCal (Kalenderprogramm von Mac OS X). Jedes davon deckt hierbei einen ganz bestimmten Bereich ab: Evernote verwende ich, um verschiedene Notizen an einem zentralen, durchsuchbaren Ort sammeln zu können. Da diese Notizen online abgelegt sind, habe ich jederzeit und überall darauf Zugriff. In Things speichere ich sämtliche ToDos, die keinen festen Termin haben. Hierbei lässt mich Things meine ToDos einteilen in Aufgaben, die möglichst heute (oder auch morgen) erledigt werden sollen, solche die demnächst anstehen, und schliesslich die, die irgendwann mal erledigt werden sollen. Zu guter Letzt trage ich in iCal alle Termine ein, die festen Zeiten unterliegen und durch die eher grobe Einteilung von Things nicht gründlich erfasst werden würden. Die Daten von Things und iCal werden hierbei zentral auf einem Arbeitsrechner abgelegt, der über eine verschlüsselte Verbindung vom Internet erreichbar ist. So kann ich von jedem Computer und Smartphone, auf dem diese Programme installiert sind, auf alle Daten zugreifen.

Dein Rat, was empfiehlst Du allen, die am Anfang ihrer Organisation stehen?

Zunächst sollte man sich darüber im Klaren sein, wo man seine persönlichen Daten ablegen möchte und wo nicht. Privatadressen, PINs, Passwörter oder ähnlich sensitive Daten sollten so abgelegt sein, dass andere Personen keinen Zugriff darauf haben — am besten also auf einem eigenen Server. Anschließend, sollte man sich einfach selbst die verschiedenen Möglichkeiten, die noch übrig bleiben, anschauen und vor allem selbst ausprobieren. Foren und Benutzermeinungen können hierbei insofern hilfreich sein, dass eventuell relevante Schwächen und Stärken der Programme herausgestellt werden. Man sollte auch stets im Hinterkopf behalten, wofür die Programme eingesetzt werden sollen. Für mich war es wichtig, dass es für jede Information (Termin, ToDo, Notiz etc.) genau einen Ort gibt, an dem ich suche. Welche Information ich in welches Programm eintrage, habe ich hierfür ziemlich genau festgelegt. Zu guter Letzt sollte der Aufwand, der in die alltägliche Benutzung dieser Programme gesteckt wird, deutlich im Hintergrund stehen. Dazu zählt neben der Zeit, die in das Eintragen solcher Termine etc. fließt, auch die Zeit, um eben diese wieder zu finden. Das Einordnen in Kategorien hilft hier. Inwiefern man davon aber Gebrauch macht, sollte jeder für sich selbst abwägen. Tief verschachtelte Kategorien anzulegen, nur weil ein Programm das unterstützt, kann der falsche Weg sein. Kurzum, man sollte darauf achten, dass die Programme einen bei der Organisation lediglich unterstützen. Der eine landet am Ende seiner Überlegungen vielleicht bei einem konventionellen Terminplaner, der andere bei einer Vielzahl von Programmen.

★ Historious, oder Lesezeichen mit Zeitreise

Mon, 23 Aug 2010 10:55:00 GMT

“Es wäre gut Bücher kaufen, wenn man die Zeit, sie zu lesen, mitkaufen könnte", so Arthur Schopenhauer über die Lust neues aus Büchern zu lernen und die fehlende Zeit, das auch wirklich zu tun. Hat man doch mal die Zeit und Ruhe gefunden, ein Buch zu lesen zu lesen, erinnere man sich nach geraumer Zeit nur noch vage an den exakten Inhalt. Aus diesem Grund schreibe ich alles Interessante aus einem Buch auf. Damit entsteht eine Sammlung von Lesezeichen, mit der ich leicht wiederfinden kann, woran ich mich nur vage erinnere.

Das gleiche Problem tritt auch bei der täglichen Recherche im Internet auf. Man weiß oft im Nachhinein, dass man etwas gefunden hat, aber selten genau wo und was. Alle Browser bieten dafür Lesezeichen an. Lesezeichen haben jedoch den schwerwiegenden Nachteil, dass sie stets nur eindimensional kategorisiert werden können. Ganz ähnlich zu Ordnern für die E-Mail-Organisation ist es schwierig, sie wieder aufzufinden, falls man nicht nach demselben Schlagwort sucht unter dem man das Lesezeichen einsortiert hat. Ich löse diese Problem, indem ich gefundene Fakten und Informationen per Evernote-Clipper in Evernote ablege und damit im Volltext durchsuchbar wiederfinden kann.

Bei vielen Lesezeichen ist jedoch nicht unbedingt der Inhalt, sondern der angebotene Dienst das Wichtige — zum Beispiel die Reiseauskunft der Bahn, Kochrezepte oder der Export meiner Daten aus Google. Für diese Lesezeichen ist es deswegen nicht sinnvoll, sie in Evernote abzulegen.

Für denn Fall, dass man nicht einen bestimmten Inhalt, sondern die Webseite selbst wiederfinden möchte, ist Historio.us genau die richtige Anwendung. Historio.us ist eine persönliche Suchmaschine für Lesezeichen, die für jedes neue Lesezeichen nicht nur URL und Titel, sondern den gesamten Inhalt der betreffenden Webseite in einem Volltextindex speichert. Auf diese Weise ist es leicht, Webseiten wiederzufinden, ohne den konkreten Namen, Titel oder abgelegten Ordner zu kennen. Da Historio.us die gesamte Webseite speichert, kann man leicht in der Internetzeit zurück zu dem Zeitpunkt reisen zu dem man das Lesezeichen gesetzt hat.

http://ueberallbuero.de/wp-content/uploads/2010/08/historious_ub_action.png

Die Bedienung von Historio.us ist denkbar einfach. Nachdem man sich angemeldet hat, kann man ein Bookmarklet im Browser installieren, das auf Knopfdruck die aktuelle Seite in Historio.us speichert (s. roten Pfeil). Daraufhin erscheint kurz ein rotes Fenster, bis die Seite gespeichert und indiziert worden ist.

Die Suche ähnelt sehr stark der Google-Suchmaske und ist schlicht aufgebaut. Erinnert man sich zum Beispiel einen Artikel über Post-its gelesen zu haben, ohne genau zu wissen wo, gibt man den Suchbegriff ein und erhält das Lesezeichen zu Überallbüro.de.

Historio.us bietet noch weitere Funktion, wie das Austauschen und Veröffentlichen von Lesezeichen und ist kostenlos nutzbar, da es über Werbung finanziert wird.

Anstatt in unübersichtlichen Ordnerhierarchien im Browser herumzusuchen und ein Lesezeichen nach dem anderen durchzuprobieren, spart Historio.us viel Zeit. Versucht es selbst oder habt ihr vielleicht bessere Ideen, Lesezeichen wirklich sinnvoll zu nutzen?

Verwandte Artikel:

★ Post-its, oder die freien Gedanken festhalten

Mon, 09 Aug 2010 08:17:00 GMT

“Die Gedanken sind frei,sie fliehen vorbei”. Dieses Volkslied dichtet von der Freiheit der Gedanken; aber es zeigt im übertragenen Sinne auch eine zweite wichtige Eigenschaft unserer Gedanken: Es ist schwierig sie zu lenken bzw. festzuhalten.

Unser Gehirn arbeitet nicht nur linear und zielgerichtet sondern auch parallel und assoziativ. Wenn wir an einem Text, an einem Vortrag arbeiten oder allgemein über ein Problem nachdenken, so versuchen wir analytisch und linear vorzugehen. So haben wir es in der Schule gelernt. Dennoch haben wir manchmal das Gefühl mit den Gedanken abzuschweifen. Wir verlieren uns in immer mehr Abzweigungen unseres logischen Denkens.

Assoziatives Denken
Dies ist kein Fehler oder Konzentrationslosigkeit. Ganz im Gegenteil: Das ist unser assoziatives Gehirn, dass aus Erlerntem, Erfahrungen und Erkenntnissen neue Ideen und Lösungen zu unserem Problem kombiniert. Es fühlt sich jedoch im Gegensatz zum linearen Denken sehr sprunghaft an.

Analyse vs. Synthese
Diese Assoziationsfähigkeit unseres Gehirn können wir nicht nur zur Problemlösung, sondern auch zum Lernen nutzen. Uns wird beigebracht analytisch abstrakte Konzepte zu verstehen, um sie dann auf konkrete Fragen anzuwenden. Jedoch ist unser Gehirn seit der Urzeit eher auf das beispielhafte, synthetische Lernen programmiert. Es fällt uns leichter, aus Einzelbeispielen ein abstrakteres Verständnis zu erarbeiten. Aus diesem Grund fordern wir im Matheunterricht stets Beispiele anstatt abstrakte Formeln.

Anstatt also Gedanken in eine Richtung zu zwingen, ist es häufig sinnvoll das Gehirn erstmal machen zu lassen, was es besonders gut kann: frei assoziieren. Damit dies produktiv eingesetzt werden kann, ist es wichtig, die Gedanken festzuhalten. Ich nutze dafür Post-its.

Schreiben

Wenn ich einen neuen Artikel schreibe, weiß ich meist, was die Aussage sein soll. Jedoch ist der Weg bis zur geschriebenen Endversion noch lang. Ich nehme mir dann ein Post-it und schreibe dieses Ziel auf (s. 1.). Danach beginne ich meine Gedanken aufzuschreiben: Einleitung, Argumente, Beispiele, Motivation, Fazit …

Jeder Gedanke, jede Idee bekommt ein Post-it. Mit der Zeit entwickelt sich ganz automatisch die Struktur des Artikels, es entstehen Kapitel (s. 2.). Diesen Kapiteln kann ich dann meine Gedanken zuordnen. Indem sich die Post-its ganz leicht umkleben lassen, ist es sehr leicht die Gedanken zu strukturieren. Argumentationen klebe ich Argument für Argument aufeinander.

Lesen

Wenn ich ein neues Problem zu lösen habe, beginne ich meist damit, zu recherchieren. Der erste Schritt ein Problem zu lösen, ist es, das Problem zu verstehen.

Dafür schreibe ich das Problem bzw. die Frage auf ein Post-it (s. 1.) und fange an in den passenden Büchern zu lesen. Mein assoziatives Gehirn denkt während dessen die ganze Zeit weiterhin über das Problem nach und so gewinne ich plötzlich neue Lösungsideen. Diese schreibe ich schnell auf (s. 2.) und lese weiter.

Während ich das Buch durcharbeite, mache ich mir Notizen auf Papier (s. 3.), da ich mir so die Inhalte besser einpräge. Es erleichtert damit auch die Assoziation, denn die Inhalte erreichen mein Gehirn so über zwei Sinne verstärkt: Sehen und Fühlen.

Entwerfen

Wenn ich ein neues Programm schreibe, entwickelte ich es zuerst auf Papier. Es ist ähnlich wie beim Schreiben eines Artikels — ich versuche erst unabhängig vom Text über den Algorithmus nachzudenken.

Zuerst schreibe ich auf, was das Programm leisten soll (s. 1.). Dann präzisiere ich diese Aufgabenstellung und zerlege sie in Teilprobleme. Dafür klebe ich das Post-it auf ein Blatt Papier, um mehr Platz zu haben. Wie in diesem Beispiel, werden es dann meist mehrere Blätter, bis ich den Entwurf des Programms fertig habe. Auf weiteren Post-it schreibe ich dann die Teilschritte auf, die ich zum Erstellen des Programms lösen muss (s. 2.).

Auf diese Weise muss ich nur die Post-its vor Augen haben, um die Teilaufgaben anzugehen. Wichtige Aspekte schreibe ich gesondert auf, damit diese ebenfalls stets präsent sind (s. 3.).

Warum Post-its?
Meine Gedanken fliegen schnell und nicht immer kontrollierbar, wenn ich meine Aufgaben erledige. Dies ist jedoch keine Schwäche, sondern ganz im Gegenteil eine Stärke meines Gehirns. So flexibel es dabei ist, so flexibel muss ich diese Gedanken auch aufschreiben, möchte ich sie später gezielt verwenden.

Post-its fassen genau einen Gedanken und können leicht hin und her geschoben werden. Klebt man sie aufeinander, gruppiert man Gedanken zu einem zusammengehörigen Aspekt. Da man sie immer aneinander kleben kann, gibt es stets genügend Platz, um zu zeichnen, schreiben oder verbinden — anders als bei beschränkten DIN-A4. Mit Hilfe von unterschiedlichen Farben kann man Post-its thematisch voneinander trennen. Die Post-its zur aktuellen Aufgabe haben eine andere Farbe als diejenigen für Tagesnotizen; also für Ideen, die man spontan zu einem anderen Thema bekommt.

Zum dauerhaften Speichern schreibe ich entweder eine kurze Zusammenfassung oder ich digitalisiere die Post-its. Die Bilder für diesen Artikel habe ich mit der Kamera meines Smartphones aufgenommen, aber man kann auch einen Scanner nutzen. In beiden Fällen lege ich das Ergebnis meiner Überlegungen in Evernote ab, so dass ich überall und jederzeit darauf zugreifen kann.

Post-its für Dich?
Assoziatives Denken ist eine enorm mächtige Fähigkeit des menschlichen Gehirns, die man täglich produktiv einsetzen kann. Egal ob für Aufsätze, Vorträge, gezieltes Lesen und Lernen oder allgemein zum Nachdenken. Um es jedoch effektiv einsetzen zu können, muss die Arbeitsmethode dazu passen. Mir helfen dabei Post-its sehr gut.

Nimm die Beispiele aus diesem Artikel und versuche Deine eigene, persönliche Methode aus ihnen zu entwickeln und berichte in den Kommentaren von Deinen positiven und negativen Erfahrungen.

Verwandte Artikel:

Ideenkiste, oder Sammeln mit dem Überallelefanten

★ Interview, oder Simone Jansons Überallbüro

Mon, 02 Aug 2010 07:40:00 GMT

©Anja Müller emanya-photography.com

Im heutigen Interview gewährt Journalistin, Buchautorin und Bloggerin Simone Janson einen Einblick in ihre Arbeitsweise und ihr Überallbüro. Sie geht dabei auf die Umstellung ins Überallbüro und die damit verbundenen Änderungen ihres (Arbeits-)lebens ein. Detailliert beschreibt sie, welche technischen Lösungen sie für ihre neue Arbeitsweise einsetzt. Zum Schluss gibt sie noch eine Rat, wie man selbst freier und selbstständiger arbeiten kann.

Simone Jansons inhaltliche Themenschwerpunkte sind Beruf und Bildung. Seit 1996 arbeite sie im In- und Ausland als Journalistin, seit 2003 als Buchautorin. Zeitweise war sie feste Redakteurin zweier Zeitschriften der Bundesagentur für Arbeit.

Das Interview

Der Job, oder was ist Dein Tätigkeitsbereich?

Ich bin seit 7 Jahre freie Journalistin mit Schwerpunkt Karriere & Bildung. Das heißt ich recherchiere, interviewe, lese, schreibe und zwar für diverse Medien wie RP-ONLINE oder ZEIT-ONLINE. Außerdem habe ich 10 Bücher geschrieben, zum Großteil über Zeitmanagement und Existenzgründung - also Themen aus meiner Erfahrung als Selbständige.

Einen immer größer werdenden Teil meiner Zeit wende ich allerdings für meinen Karriereblog auf. Hierbei kommt zu der journalistischen Tätigkeit auch die Arbeit als “Webdesignerin” hinzu, die technisch viel aufwändiger ist: Denn mein Blog soll gut aussehen, benutzerfreundlich sein und technisch einwandfrei funktionieren. Dafür sind ständige Anpassungen notwendig. Momentan experimentiere ich außerdem mit dem Fotografieren für den Blog herum, vielleicht kommen demnächst auch Videos hinzu.

Schließlich gibt es noch die ganzen Nebenaufgaben, die leider auch viel Zeit kosten: Bürokratie und Buchhaltung, Kommunikation mit Kunden und Lesern, sowie Eigen-PR. Darunter fasse ich z.B. Interviews (für diesen Blog und andere Medien), aber auch meine Social Media Aktivitäten bei Twitter und Facebook. Was ich aber zum Glück kaum noch machen muss: Akquise. Meine Auftraggeber finden mich entweder über das Internet oder mein Netzwerk. Somit bleibt mehr Zeit für die eigentliche Arbeit.

Der Alltag, oder wie sieht Dein normaler Arbeitstag aus?

Meist schreibe ich noch vor dem Frühstück den ersten Artikel - ich habe meine besten Ideen morgens. Und natürlich werfe dabei auch einen Blick auf Blog, E-Mails, Twitter, Facebook und Co. Auch wenn viele Leute das anders sehen, könnte das vermutlich auch warten, aber ich bin einfach neugierig.

Wenn ich “Pech” habe, ist gerade eine Anfrage reingekommen, irgendetwas spannendes passiert oder ich muss mal schnell etwas technisches erledigen… und das dauert dann manchmal bis nachmittags. Mein Problem ist, dass mir die Arbeit manchmal solchen Spaß macht, dass ich komplett die Zeit und mit ihr gleich das Pausemachen vergessen kann. Flow nennt man das wohl. Gesund ist das nicht! Umgekehrt lasse ich an manchen Tagen den Computer (und das Telefon) bewusst aus, um zu entspannen oder andere Dinge zu machen. Ich versuche schon seit geraumer Zeit, einen geregelten Rhythmus in meine Arbeit zu bekommen, aber tatsächlich kommt es eher vor, dass ich tagelang durcharbeite und dann gar nichts mache.

Ich bin allerdings gerade dabei, den technischen und administrativen Aufwand, der eine Zeit lang überhand genommen hatte, wieder zurückzufahren: In Zukunft möchte ich wieder mehr typisch journalistisch unterwegs sein, Geschichten schreiben, Fotos machen - Berlin bietet da einiges an Material!

Das Überallbüro, oder wie unterscheidet sich Dein Arbeitstag von früheren festen Büros?

Na zum Beispiel darin, dass solch unregelmäßige Arbeitszeiten da nicht möglich waren. Oder darin, dass ich gerade im Charlottenburger Schlosspark sitze und diese Fragen beantworte. Auch darin, dass ich morgens eben gleich anfangen kann mit der Arbeit und nicht erst ins Büro fahren oder ineffektiv in irgendwelchen Meetings herumhängen muss. Und schließlich darin, dass einen kein Chef böse anknurrt, wenn man zwischendurch mal zu irgendwelchen Ämtern muss, die ja bekanntlich auch nur während normaler Arbeitszeiten aufhaben.

Aber mal im Ernst: So groß sind die Unterschiede was die Arbeitszeiten angeht nicht. Auch wenn ich mir das anfangs anders vorgestellt habe, bin ich im Laufe der Zeit doch verstärkt dazu übergegangen, zu normalen Bürozeiten zu arbeiten. Einfach weil man die meisten Leute, mit denen man zu tun hat, dann erreicht oder selbst kontaktiert wird.

Die Technik, oder welche Hardware und Software setzt Du ein?

Fürs mobile Arbeiten benutze ich das Nokia-Netbook 3G und derzeit ein Samsung Galaxy S7500. Über beide Geräte habe ich auf meinem Blog ausführliche, mehrteilige Testberichte verfasst. Das Handy wird vermutlich in absehbarer Zeit ein anderes werden.

Im Büro habe ich gerade von einem 4 Jahre alten HP-Notebook (nx6325) wieder auf einen Desktop PC (wieder von HP) mit 22 Zoll-Monitor von Asus umgestellt. Grund: Für die Arbeit an der Website, Bild und eventuell später Video brauche ich einen leistungsfähigen Rechner und einen großen Monitor. Für unterwegs war mir das 15-Zoll-Notebook hingegen immer zu schwer, ich hatte es so gut wie nie dabei (was auch daran liegt, dass ich kein Auto habe, sondern mit Rad, ÖPNV und sehr viel zu Fuß unterwegs bin). Das Netbook passt hingegen in die Handtasche.

Für Office-Anwendungen, zum Schreiben von einzelnen Texten, E-Mails usw. ist das Netbook gut. Für umfangreichere Texte (z.B. bei Büchern), Arbeiten an der Website oder Bildbearbeitung ist mir das Display des Netbooks allerdings zu klein und der Rechner zu leistungsschwach. Insofern ist mein Überallbüro ein wenig begrenzt. Allerdings habe ich festgestellt, dass ich Aufgaben, bei denen ich mich stark konzentrieren muss oder die unbedingt fertig werden müssen, besser im Büro mache: Da brauche ich einen ergonomischen Arbeitsplatz.

Als Software auf dem Desktop nutze ich Ubuntu-Linux 10.04 (*kostenlose und sehr anwenderfreundliche Linux-Distribution, *Anm. d. Red.)**. Auf dem Notebook vorher war 8.04. Eingestiegen bin ich in Ubuntu 6.0 – damals noch aus Kostengründen. Zu der Zeit war Ubuntu noch deutlich mehr Frickelei. Dadurch habe ich mich aber daran gewöhnt und finde mittlerweile Ubuntu viel besser als Windows: Sicherer, schneller, Software kann man bequem über die Paketquellen nachinstallieren und deinstallieren, ohne dass das Betriebssystem instabil wird. Der größte Vorteil ergibt sich allerdings in der übersichtlicheren Dateiverwaltung und beim Brennen (Windows akzeptiert ja bekanntlich nicht jeden Dateinamen und tiefere Verzeichnisse) sowie bei der Sicherung von Daten. Vermutlich auch alles einfach eine Frage der Gewohnheit.

Außerdem hat sich 10.04 praktisch von alleine installiert und die notwendigen Programme bis hin zur Social-Media-Integration in den Desktop waren auch schon dabei. Auch mein Drucker und mein Scanner waren schnell ans Laufen gebracht (wobei man aber sagen muss, dass Brother als eine der wenigen Firmen Linux-Treiber zur Verfügung stellt). Dazu kommt die Unterstützung einer großen Community, die zu quasi zu jedem Problem eine googelbare Lösung bietet. Nur bei der elektronischen Steuererklärung muss das Finanzamt jetzt noch nachziehen…

Auf dem Netbook läuft Windows 7 in der abgespeckten Starter-Edition, von der man nicht viel erwarten darf. Was mich nervt, ist das ständige aufpoppen irgendwelcher Update-Fenster und die Aktualisierung der Virensoftware. Ich muss aber zugeben, dass ich mich gar nicht mehr groß mit Windows beschäftigen mag. Wenn ich noch herausfinde, wie ich Ubuntu vom USB-Stick installiere, werde ich vielleicht auch mal die Netbookversion ausprobieren, die ja im Gegensatz zu Windows auch an den Gebrauch kleiner Bildschirme angepasst sein soll.

Auf beiden Rechnern läuft Thunderbird für E-Mails, Firefox und OpenOffice (*kostenloses Office-Paket vergleichbar mit Microsoft Office, *Anm. d. Red.)**. Einige Formatierungsprobleme zwischen OpenOffice und MS-Office sind leider noch nicht ganz beseitigt, aber auch da hat sich viel getan.

Meine Kontakte gleiche ich zwischen Thunderbird und Google mit Zindus (*kostenlose Synchronisations-Software, *Anm. d. Red.)** ab, die Termine werden in den Google-Kalender übernommen. Von da gelangen alle Daten automatisch auf mein Android-Handy. Übrigens war das der letzte Schritt, der Windows praktisch überflüssig machte: Die Daten überspiele ich jetzt via FTP (mit Swift-FTP wird das Handy zwischendurch zum Server) und muss den PC gar nicht mehr mit dem Handy verbinden, was mit Ubuntu nicht so einfach ist.

Die beiden Computer gleiche ich mit einer externen Festplatte ab, die auch zur Datensicherung dient. Hilfe bringt da das Programm Synkron, das sowohl auf Ubuntu wie auch Windows funktioniert. Mit Cloud-Computing konnte ich mich bislang nicht anfreunden, schon wegen der Masse an Daten, die ich synchronisieren muss. Denn erfahrungsgemäß ist es nicht praktikabel, nur Teilbereiche meiner Daten abzugleichen. Und Fotos mit hoher Auflösung sind nunmal sehr groß… Allerdings bietet Ubuntu da jetzt einen Direkt-Zugang zu Ubunt-One… mal sehen… Ebenfalls wichtig: Eine Passwortverwaltung für all die vielen Internet-Passwörter, die auf allen Systemen, auch auf Android läuft. Ich nutze da Keepass.

Generell achte ich bei der Benutzung mehrerer Rechner darauf, dass ich möglichst die gleichen Programme und die gleiche Anordnung nutzte, sonst komme ich komplett durcheinander.

Die Work-Life-Balance, oder wie hat sich Dein Leben durch die Arbeitsumstellung verändert?

Vor allem dahingehend, dass ich mehr Spaß an der Arbeit habe. Das liegt daran, dass ich mir im Prinzip die Zeit frei einteilen kann. Auch wenn ich dann oft sogar mehr arbeite als früher, ist dieses Gefühl der Selbstbestimmung doch sehr wichtig. Ein anderer Punkt ist, dass ich mir aussuchen kann, woran ich inhaltlich arbeite und für wen. Das ist allerdings per se kein Vorteil der Selbständigkeit: Ich kenne viele Freiberufler, die sehr viel enger in die Arbeitsabläufe ihrer Auftraggeber eingebunden sind (und darüber auch gerne klagen). Umgekehrt gibt es auch Angestellte, die sich einige Freiheiten herausnehmen können.

Dein Rat, oder was empfiehlst Du anderen, die noch nicht im Überallbüro arbeiten?

Naja, in den USA gibt es ja schon Firmen, die es ihren Mitarbeitern gestatten, zu arbeiten, wann und wo sie wollen, Hauptsache die Arbeit ist hinterher fertig. In Deutschland wird es vermutlich noch eine Weile dauern, bis sich diese Sichtweise durchsetzt, weil das Bedürfnis nach Kontrolle in Unternehmen nach wie vor groß ist. Man kann das Thema aber durchaus mal bei seinem Chef anklingen lassen, weil ja der Vertrauensvorschuss oft auch die Eigenverantwortung und die Produktivität des Mitarbeiters fördert.

Für Mitarbeiter, die so arbeiten, kann das aber auch Nachteile haben: Es besteht die Gefahr der Selbstausbeutung, z.B. weil man alles besonders gut machen will oder weil man viel mehr Aufgaben in einen Zeitraum hineinpackt, als man bewältigen kann. Ich habe das zu Beginn meiner Selbständigkeit auch gemerkt und aus dieser Erfahrung heraus mein Buch „Die 110%-Lüge. Wie Sie mit weniger Perfektion mehr erreichen“ geschrieben.

Ich habe mir dann mit der Zeit klar gemacht, was ich wollte - nämlich mehr Freiheit und Unabhängigkeit - und gezielt darauf hingearbeitet, z.B. indem ich einige Aufträge oder Jobangebote, die vielleicht sogar etwas mehr Geld gebracht, aber mich mehr eingeschränkt oder langfristig nichts gebracht hätten, abgelehnt habe. Das kostet anfangs natürlich Überwindung und sicher habe ich dadurch auch so manchen (schlechten) Kunden verloren, aber hatte dann mehr Zeit für wirklich gute Aufträge.

Insofern ist mein Rat: Wissen was man will, das im Auge behalten und sich nicht durch Unsicherheiten aus der Ruhe bringen lassen.

★ ScanSnap, oder der papiertragende Babyüberallelefant

Mon, 26 Jul 2010 07:00:00 GMT

Das Mooresches Gesetz (engl. Moore’s Law) besagt, dass sich die Größe von Computerchips bei gleichbleibender Leistungsfähigkeit alle 18 Monate halbiert. Moore beschrieb damit 1965 die Grundlage der digitalen Revolution, die immer kompaktere Geräte mit höherer Leistung erlaubt. Die Chipentwicklung gipfelt heute in der Möglichkeit, alle unsere Aufgaben im Überallbüro zu erledigen.

Im früheren Artikel “ScanSnap, oder der papiertragende Überallelefant” beschreibe ich, wie man mit Papier im Überallbüro umgehen kann. Papier ist nach wie vor ein wichtiges Arbeitsmittel, aber es lässt sich nicht so leicht im Überallbüro mitführen wie digitale Daten. Aus diesem Grund scanne ich mit Hilfe des Fujitsu Scanners “SnapScan S1500” Dokumente ein, die für meine tägliche Arbeit relevant sein können und speichere sie in Evernote. So gelingt es mir, auch Papierdokumente ins Überallbüro mitzunehmen. Mehr Details und wie ich mit gescannten Dokumente arbeite findet ihr im oben genannten Artikel.

Wie Papier kann auch ein Scanner leider nur an einem Ort stehen und genutzt werden. Dieser Artikel beschreibt den Fujitsu Scanner “SnapScan S1300”, der als tragbarer Scanner hilft, sich vom Scanner im Büro zu lösen und dort zu scannen, wo man gerade arbeitet.

SnapScan S1300
Der Scanner ist konsequent für die Arbeit unterwegs ausgelegt. In zusammengeklappter Form ist er sehr handlich. Obwohl dem Scanner ein Netzteil beiliegt, kann man ihn über ein ebenfalls beigelegtes Y-USB-Kabel aus den USB-Ports eines Notebooks mit ausreichend Strom versorgen; das ist sehr pfiffig, da man so weniger zu tragen hat. Leider liegt keine Tasche oder Hülle zum Schutz bei.

Die Scanqualität entspricht dem größeren Modell S1500 und ist hervorragend für die Dokumentendigitalisierung geeignet. Gescannt werden können 4 Seiten vollduplex in 1 Minute. Dies ist 10 mal langsamer als der S1500 arbeitet und bei größeren Datenmengen langwierig.

Die Scan-Software “ScanSnap-Manager” ist die gleiche wie beim S1500 und zeichnet sich durch einfache Bedienung und gute Integration in meine Arbeitsabläufe aus. So lassen sich gescannte Dokumente ohne Umwege, automatisch in Evernote als neue Notizen einfügen. Sie liegt sowohl für Mac OS X als auch Windows bei.

Scannen im Überallbüro
Grundsätzlich fällt bei mir nicht so viel Papier an, dass ich ständig einen Scanner griffbereit haben muss. Ich scanne Dokumente meist während meiner Abendroutine zu hause ein. Während meiner Arbeit mit diesem mobilen Scanner hat er sich jedoch als praktische Hilfe für das Festhalten von handschriftlichen Notizen, Anmerkungen zu Papierdokumenten und Korrekturen in meinem Büro erwiesen. Auf diese Weise gelangen Notizen leicht in meine Evernote-basierte Wissensdatenbank.

Wer jedoch mit mehr Papier zu tun hat und nicht jeden Tag am gleichen Ort arbeitet — wie z.B. Berater und Vertreter — kann mit dem SnapScan S1300 leicht und qualitativ hochwertig Dokumente digitalisieren wo und wann er will.

Und Du? Hilft Dir ein Scanner Deine Arbeit zu erleichtern oder scannst Du Deine Dokumente gar nicht?

Verwandte Artikel:

ScanSnap, oder der papiertragende Überallelefant

★ Die Mauer, oder wie man Gewohnheiten ändert

Tue, 13 Jul 2010 13:58:00 GMT

Tom Buhrow sprach am vergangenen Samstag vor den diesjährigen Absolventen der Universität Bonn. Er beschrieb die Mauern, die man im Leben überwinden muss, um seine Ziele zu erreichen. Nur wer sich anstrengend, Rückschläge in Kauf nimmt und nicht nachgibt, wird seine (wahren) Ziele erreichen.

Ich höre bei meinen Seminaren, von meinen Kunden und meinen Kollegen immer wieder, dass es ja für mich einfach wäre im Überallbüro zu arbeiten, sie jedoch keine Zeit hätten ihre Arbeitsgewohnheiten umzustellen. Das Tagesgeschäft ließe einfach keine Zeit dafür.
Diese Aussage ist im doppelten Sinne falsch!

**Gewohnheiten zu ändern kostet Kraft und Überwindung
**Laut dem Psychologen Kurt Lewin ist das Erlernen einer neuen Gewohnheit stets mit dem Verlernen alter Gewohnheiten verbunden. Dieser Prozess erzeugt Unsicherheit, da man von bewährtem Verhalten abweichen und unerprobtes Verhalten anwenden muss. Ferner glauben viele, dass solche Veränderungen ein Zugeständnis sein, man habe falsch gearbeitet.

Gewohnheitsänderungen sind jedoch ganz im Gegenteil ein Zeichen dafür, dass man sich weiterentwickelt. Es ist also nicht die Zeit die uns von Veränderungen abhält, sondern es sind die Anstrengung, Unsicherheit und Scham.

**Das Tagesgeschäft ist eine Ausrede und eine schlechte noch dazu
**Programmierer stehen unter enormem Zeitdruck, um ihr Produkt fertig zu stellen. Diesen Zeitdruck nutzen sie häufig als Begründung für unsaubere Implementierungen. Schließlich bliebt einfach keine Zeit für langsames Arbeiten. Kurzfristig mag dieses Vorgehen sogar funktionieren, jedoch auf mittlere und längere Sicht führt es zu unwartbarer Software, die keiner mehr reparieren kann. Das Buch “Clean Code” antworten auf diese Behauptung:

The only way to go fast, is to keep the code as clean as possible.

Das heißt, dass wir nur durch bessere Methoden unser Tagesgeschäft bewältigen können, anstatt alten Arbeitsgewohnheiten stur zu folgen.

**Drei Schritte zum Ändern von Gewohnheiten
**Nimmt man Veränderungen als Weiterentwicklung war und sieht das Ziel, durch bessere Arbeitsgewohnheiten, effektiver zu arbeiten, dann helfen die folgenden drei Schritte, Gewohnheiten tatsächlich zu ändern.

Kleine Schritte: Ändere jeweils nur eine Gewohnheit zur gleichen Zeit. Auf diese Weise passt Du Dein Arbeitsverhalten in kleinen, erreichbaren Schritten an.
Zeit: Änderungen brauchen Zeit, denn sie können nicht von heute auf morgen funktionieren. Sei geduldig und lass Dich von Rückschritten nicht abbringen.
Protokoll: Schreib ein kurzes Tagebuch zum Fortschritt Deiner Gewohnheitsänderungen: Was hat heute gut geklappt, was nicht. Was werde ich morgen anders machen?

Zusätzlich kann es helfen, Freunden und Kollegen von den geplanten Änderungen zu erzählen. Umso bekannter man seine Pläne macht, desto schwieriger wird es sie aufzugeben.

Es ist immer schwierig eine Mauer zu überwinden, aber das geht allen Menschen so. Ich habe meine Arbeitsgewohnheiten auch nicht von heute auf morgen über den Haufen geworfen. Der Unterschied zwischen Erfolg und Misserfolg ist jedoch stets mein Wille gewesen, morgen besser zu arbeiten als heute. Folge den drei Schritten und es wird auch Dir gelingen, produktiver und motivierter zu arbeiten, wo und wann Du willst.

Und Du? Wie gehst Du mit Gewohnheitsänderungen um? Was hat Dir geholfen und welche Schwierigkeiten musstest Du überwinden?

Verwandte Artikel:

Schlaue Ziele, oder Aufgaben mit Fingerspitzengefühl

★ Konzentrationsuhr, oder die getaktete Ablenkung

Mon, 28 Jun 2010 08:00:00 GMT

Vor ca. 2,5 Millionen Jahren hat der frühzeitliche Mensch das Pebble-Tool erfunden; das erste Werkzeuge und die Vorversion des Faustkeils. Diese Erfindung ging auf veränderte Umweltbedingungen zurück. Das trockenwerdendere Klima brachte Pflanzen mit härterer Schale um ihre Früchte hervor und der Mensch benötigte Werkzeuge, um diese zu knacken.

Ich habe schon oft über die Herausforderungen der modernen Arbeitsumwelt gesprochen und insbesondere den Aspekt des ablenkungsfreien Arbeitens beleuchtet. Was jedoch, wenn die Selbstdisziplin einfach nicht ausreichen will, konzentriert zu arbeiten? In diesem Fall braucht man ein Werkzeug zur Unterstützung, um trotz Ablenkungsversuchungen zu arbeiten: die Konzentrationsuhr.

Ablenkung

Ablenkung am Arbeitsplatz tritt in verschiedenen Formen auf: Anrufe, Kollegen, abschweifende Gedanken und Wartezeiten, wie zum Beispiel durch Downloads und Warteschleifen. Es geschieht schnell, dass man dann die Konzentration verliert und ein “kurzes Pläuschchen” hält, schnell mal wieder E-Mails abruft oder die Lieblings-Web-Seite ansteuert. Leider führen diese kurzen Ablenkungen dazu, dass unser Gehirn ständig zwischen verschiedenen Aufgaben umschalten muss und dadurch zu hohem Produktivitätsverlust.

Selbstdisziplin oder Konzentrationsuhr

An guten Tagen gelingt es mir leicht, den Ablenkungsversuchungen zu widerstehen. Dann ignoriere ich Anrufe und Kollegen, schreibe mir Gedanken schnell auf ein Post-It und konzentriere mich während Wartezeiten weiterhin auf meine aktuelle Aufgabe. An schlechten Tagen fällt mir dies jedoch schwer und der Mauszeiger scheint fast selbstständig zum Browserfenster zu wandern.

An diesen schlechten Tagen hilft mir die Konzentrationsuhr*. Bevor ich eine Aufgabe angehe, überlege ich, wie lange ein konkreter Schritt zur Bearbeitung dieser Aufgabe dauern könnte; mal 5 min, mal 10, und auch mal 25 min. Danach stelle ich eine Stoppuhr oder einen Wecker auf diese Dauer ein und arbeite solange an meiner Aufgabe, bis die Zeit abgelaufen ist.**

Richte Deine Aufmerksamkeit auf Deine Aufgabe, bis die Uhr abgelaufen ist

Wichtig ist es, jedes Mal, wenn der Impuls zur Ablenkung kommt, die Stoppuhr im Blick zu haben und sich zu sagen: “Okay, noch 7:35 min, so lange bleib ich noch dran”. Dabei spielt es keine Rolle, ob man gerade aktiv an seiner Aufgabe arbeitet oder im Stuhl zurückgelehnt nachdenkt.

Nach Ablauf der Stoppuhr gönne ich mir 5 min Ablenkung, so dass mein Gehirn sich kurz ausruhen kann und wieder fit für die nächste Runde ist. Auf diese Weise entsteht ein getakteter Arbeitsrhythmus aus konzentriertem Arbeiten und Regenerationszeit.

Versucht es selbst

Die Konzentrationsuhr ist eine simple und leicht einsetzbare Technik, um am Ball zu bleiben. Wenn meine Selbstdisziplin mal wieder versagt, hilft mir die Konzentrationsuhr den inneren Schweinehund zu überwinden und meine Aufgaben abzuarbeiten.

Probiert es selbst und berichtet mir, wie es klappt oder was Ihr anders macht.

Verwandte Artikel:

Konzentration, oder nicht ablenken lassen

* Entlehnt habe ich die Konzentrationsuhr der Pomodoro-Technik, die eine Eieruhr — italienisch “Tomatenuhr” — nutzt. Leider schießt der Autor der Pomodoro-Technik über das Ziel hinaus und konzipiert aufbauend auf der Eieruhr eine starre und unflexible Arbeitsweise, die das “richtige” Verhalten erzwingen will.

** Tipps für Fortgeschrittene: Man braucht keine echte Stoppuhr. Mittlerweile nutze ich nur die Uhrzeitanzeige meines Computers und schreibe mir die Endzeit auf ein Post-It. Dieses klebe ich auf meinen Bildschirm und dann geht es los.

★ KISS, oder das Einfache siegt über das Komplizierte

Mon, 14 Jun 2010 08:00:00 GMT

Ockhams Rasiermesser ist ein Prinzip aus der Philosophie und Methodenlehre und besagt, dass die einfachste Theorie zur Beschreibung einer Beobachtung meist die richtige ist.

In der Informatik ist Ockhams Rasiermesser als das “Keep it simple stupid” (KISS)-Prinzip (englisch, deutsch) bekannt. Entwirft man einen Algorithmus, so sollte dieser möglichst einfach und konkret sein. Dies erreicht man, indem der Algorithmus genau eine Aufgabe löst und das so einfach wie möglich.

Obwohl KISS vielen Menschen intuitiv bewusst ist, handeln sie diesem effektiven Prinzip beim Planen und Ausführen ihrer Aufgaben zuwider.

Tooleritis
Ich beobachte immer wieder das gleiche Phänomen. Wenn sich Kollegen oder Freunde entscheiden, ihr Arbeitschaos besser zu organisieren, verfallen sie häufig der Tooleritis. Sie suchen das ausgefeilteste Organisationssystem, die umfassenste Software und die optimale Zeitausnutzung. Aufgaben bekommen verschiedenste Kontexte, Prioritäten und Farben. Jede Aufgabe wird zeitlich abgeschätzt und von der Software je nach Kalenderauslastung automatisch terminiert.

Wer unter Tooleritis leidet, macht sich zum Sklaven seiner Organisation. Die Erkrankten glauben, die Lösung für ihr ineffizientes Handeln sei die bessere Verwaltung ihrer Aufgabe und könnten damit nicht falscher liegen.

Arbeiten, nicht Organisieren
Das Ziel, seine Aufgaben zu erledigen, wird nicht durch bessere Organisation, farbige Prioritäten und Automatismen erreicht, sondern durch das Erledigen von Aufgaben. Punkt.

Organisationssysteme müssen leichtgewichtig sein. Sie unterstützen uns in unserer täglichen Arbeit, sind aber nicht unsere tägliche Arbeit.

**Einfache Lösungen
**Genau den gleichen Fehler machen viele bei der tatsächlichen Lösung einer Aufgabe. Sie streben nach der einen, allumfassenden Lösung für ihr Problem. Dabei verlieren sie aus den Augen, dass Perfektion nie erreicht werden kann. Anstatt also zu versuchen, die Superdupereinfürallemal-Lösung zu erarbeiten, ist es wesentlich sich auf die konkrete Aufgabenstellung zu konzentrieren und nur diese zu bearbeiten.

Fazit
Wenn Du das nächste Mal eine Aufgabe planst, halte inne und überlege, was die drei Kernschritte zur Lösung sind. Lass Dich nicht von zusätzlichen Erweiterungen oder “Schön wäre es, wenn man noch …” ablenken. Genauso halte inne, wenn Du beginnst die Aufgabe zu bearbeiten. Verzichte auf überflüssiges Brimborium und konzentriere Dich auf das Ergebnis.

Und Du?
Passiert es Dir auch manchmal, dass Du anstatt eine einfache Aufgabe zu lösen, der Versuchung unterliegst, allumfassende Superlösungen zu bauen, die dann am Schluss doch scheitern und viel zu viel Zeit kosten? Wie gehst Du damit um?

Verwandte Artikel:

★ 16:9, oder wie man die Bildschirmbreite sinnvoll nutzt

Mon, 31 May 2010 08:29:00 GMT

“Die Fesseln der Gewohnheit sind meist so fein, dass man sie kaum spürt. Doch wenn man sie spürt, sind sie so stark, dass sie sich (offenbar) nicht mehr zerreissen lassen.” (Samuel Johnson). Unsere Gewohnheiten sind das Ergebnis unserer Erfahrung im Umgang mit den Bedingungen unserer Umgebung. Ändert sich unsere Umwelt, vergessen wir jedoch häufig, auch unsere Gewohnheiten zu überdenken. Dies trifft insbesondere bei kleinen Änderungen zu, da sich augenscheinlich nichts geändert hat.

Eine solche unscheinbare Änderung unserer Arbeitsumgebung ist die Verbreitung von Fernsehern und Bildschirmen im 16:9 (oder ähnlich) Breitbildformat. Untersuchungen haben bereits früh gezeigt, dass das menschliche Sichtfeld eher einem Breitbildformat entspricht. Die Initiative für die Umstellung vom 4:3 auf das 16:9 Seitenverhältnis kam ursprünglich aus der Unterhaltungsindustrie — Fernsehen wir im Kino. Mittlerweile sind sogar die meisten Computer- und Notebook-Bildschirme im Breitbildformat; auch um die Darstellung von Filmen auf diesen Geräten zu verbessern.

Leider haben wir bisher unsere Gewohnheit, wie wir den Platz auf diesen Bildschirmen für die tägliche Arbeit nutzen, nicht in Frage gestellt. Die Fensteraufteilung der Programme folgt immer noch den Regeln aus der Zeit von 4:3 Monitoren. Die gängige Aufteilung “Navigation links, Übersicht rechts oben und Inhalt links unten” ist nicht mehr zeitgemäß. Die Zeilenlänge ist viel zu groß. Dadurch müssen wir beim Lesen den Kopf leicht bewegen, um die gesamte Zeile lesen zu können und es fällt dem Auge schwer, die nächste Zeile zu finden.

Wissenschaftliche Untersuchungen (engl.) haben gezeigt, dass in Print-Medien die Zeilenbreite für optimale Lesbarkeit ca. 9 - 15 cm beträgt. Neuere Untersuchungen für die Lesbarkeit an Computerbildschirmen führen Zeilenlängen von bis 18 cm als sinnvoll auf. In beiden Fällen liegt man deutlich unter der Breite von Breitbildmonitoren. Betrachtet man die Webseite des Spiegels, so fällt auf, dass die Zeilenbreite ungefähr 16 cm beträgt und damit im optimalen Bereich liegt.

Wir sollten die Standardeinstellungen unserer Programme bzw. unsere Gewohnheit, sie zu nutzen, überdenken und den veränderten Bedingungen anpassen. Ich habe mein Mail-Programm und Evernote auf eine 3-Spaltenansicht umgestellt, so dass die Dreiteilung vertikal verläuft. Dadurch wird die Darstellung übersichtlicher und die Texte lesbarer. Es fällt mir so sehr viel leichter, längere E-Mails zu lesen und auch mal im Text zurückzuspringen.

Für Apple Mail gibt es das Plugin “Letterbox” welches die 3-Spaltenansicht erlaubt. In Thunderbird 3 ist diese Funktion bereits integriert und über das Menü “Ansicht, Fensterlayout, 3-Spalten-Ansicht” einstellbar. Evernote bietet ebenfalls von Haus aus eine 3-Spaltenansicht an. Auch in vielen anderen Programmen kann man die Bildschirmbreite effektiver nutzen.

Versucht es selbst und vergesst dabei nicht: Änderungen von Gewohnheiten sind sehr viel schwerer, die Trägheit viel größer als man denkt. Am Anfang spürt man oft Ablehnung und innerliches Widerstreben. Gebt Änderungen Zeit. Probiert es eine Woche aus und entscheidet dann, ob die neue Gewohnheit besser ist als die alte.

Und Du? Welche Gewohnheiten hast Du überwunden, um Deine Arbeitsumgebung besser auf Dich anzupassen? Lass die anderen Leser teilhaben und schreib einen Kommentar!

★ 1 Jahr Überallbüro, oder Geburtstagsverlosung

Fri, 14 May 2010 15:05:00 GMT

Heute wird das Überallbüro 1 Jahr alt. Am 14. Mai 2009 begann ich den Blog “eiGadget — Spielzeuge für Nerds” mit dem Artikel “Crashplan, oder wenn es doch mal brennt”. Die Absicht meines Blogs war es, über die Werkzeuge zu berichten, die mir meine tägliche Arbeit erleichtern. Es stelle sich schnell heraus, dass Ihr, die Leser, besonderes Interesse daran habt, wie ich diese Werkzeuge produktiv einsetze und meinen Arbeitstag gestallte. Daraus entwickelte sich das Überallbüro.

Der Erfolg von Überallbüro.de ist nur dank Euch möglich gewesen und dafür möchte ich mich herzlichst bedanken. Eure Anregungen, Kommentare und technischen Tipps waren der wertvolle Ansporn, den man als Blog-Schreiber braucht. Dafür möchte ich mich bei Euch mit einer Verlosung zum einjährigen Geburtstag des Überallbüros bedanken.

Verlosung

Ich verlose unter allen Lesern, die bis nächsten Freitag, 21.05.2010, einen Geburtstagsgruß hinterlassen, 3 mal jeweils einen Gutschein für ein einjähriges “Remember The Milk” Pro Abonnement*****. Also hinterlasst einen Geburtstagsgruß und schreibt, wie Überallbüro.de Euch im täglichen Leben geholfen oder Eure Einstellung zum produktiven Arbeiten verändert hat.

Ich wünsche Euch allen für das zweite Jahr viel Erfolg beim Umsetzen der Tipps aus dem Überallbüro. Die beliebtesten Artikel und häufigsten Suchanfragen von Google aus dem letzen Jahr findet ihr nachfolgend.

Die beliebtesten Artikel

Die häufigsten Suchanfragen von Google

“sich nicht ablenken lassen”
“Evernote sinnvoll einsetzen”
“E-Mails organisieren”

* Falls Ihr Remember the Milk schon einsetzt, könnt Ihr trotzdem an der Verlosung teilnehmen. Das Jahr wird Euch dann bei Remember the Milk gutgeschrieben.

★ Neue Wege, oder das riskante Leben

Sun, 09 May 2010 08:00:00 GMT

Die Opferzahlen des Reaktorunfalls von Tschernobyl (bereits Verstorbene sowie zu noch erwartende Todesfälle) wird auf 4.000 bis 100.000 Menschen geschätzt. Im Gegensatz dazu berichtet das Statistische Bundesamt, dass jährlich allein in Deutschland 16.000 Menschen durch Alkoholmissbrauch sterben. Allein im Jahr 2004 starben in Deutschland 41.342 Menschen durch von Tabakkonsum verursachten Lungenkrebs. Das ergibt pro Jahr ca. 47.000 Tote durch Alkohol- und Tabakkonsum.

In seinem Buch “Das Einmaleins der Skepsis: Über den richtigen Umgang mit Zahlen und Risiken” nennt Gerd Gigerenzer, Professor für Psychologie am Max-Planck-Institut für Bildungsforschung, zwei Ursachen für menschliche Ängste: Katastrophen und Unbekanntes. Wir Menschen fürchten uns mehr vor Ereignissen bei denen auf einen Schlag viele Menschen ums Leben kommen als vor dem sukzessiven Tod über eine lange Zeit. Ein Flugzeugabsturz oder ein Atomreaktorunglück machen uns mehr Angst als der schleichende Krebstod. Die Angst vor dem Unbekannten ist größer als die vor bekannten Gefahren. Bei Begriffen wie Kernenergie und Gentechnik haben wir ein mulmiges Gefühl im Bauch, die Risiken von Alkoholkonsum empfinden wir jedoch nicht als Bedrohung.

Diese Ängste sind natürliche, evolutionsbedingte Instinkte, die wir alle in uns tragen. Der bekannte Marketing-Fachmann und Blogger Seth Godin ordnet diese instinktiven Denkstrukturen unserem Reptiliengehirn zu, einem Teil des Gehirns, der sich vor Äonen gebildet hat und immer noch aktiv in uns arbeitet. Diese Instinkte hindern uns im heutigen Leben daran, Veränderungen aufgeschlossen und vorurteilsfrei zu bewerten. Allzu leicht folgen wir lieber alten Pfaden, als neue Wege zu erkunden; schließlich “haben wird das immer schon so gemacht”.

“Im Leben ist nichts sicher, außer der Tod und die Steuer”, so Benjamin Franklin und drückt damit aus, dass unser Leben voller Unsicherheiten ist — egal, ob wir auf alten oder neuen Pfaden wandeln.

Sei kreativ, wo und wann Du es am besten bist

Veränderungen müssen keine Angst machen, wenn man sie aktiv gestaltet. Dies gilt allgemein für das ganze Leben als auch für die Methoden des Überallbüros. Was früher funktioniert hat, muss nicht schlecht sein. Aber neue Vorgehensweisen können besser zur aktuellen Arbeitsumgebung passen und unser Leben erleichtern, wenn man die Angst ablegt und positiv oder sogar mit Freude die Veränderungen aufnimmt.

Leben heißt Veränderung. Wer dies akzeptiert, wer dies aktiv annimmt, geht leichter und zufriedener durch das Leben.

★ Überallbüro auf Reisen, oder Vorbereitungen für die Offline-Welt

Mon, 03 May 2010 08:00:00 GMT

“Der Sinn des Reisens besteht darin, die Vorstellungen mit der Wirklichkeit auszugleichen, und anstatt zu denken, wie die Dinge sein könnten, sie so zu sehen, wie sie sind”. Dieses Zitat von Samuel Johnson begleitete mich auf meiner vier wöchigen Reise nach Mali, Westafrika, wo ich meine Vorstellung vom jederzeit verfügbaren Internet, mit der Wirklichkeit in einem Entwicklungsland vergleichen konnte. Welche Auswirkungen dies auf die Arbeit im Überallbüro hat und wie man allgemein auf Reisen sinnvoll arbeiten kann, stelle ich in diesem Artikel vor.

Das Überallbüro nutzt die Fähigkeiten des mobilen Internets, um überall und jederzeit die gleichen Arbeitsbedingungen wiederherzustellen. Vor Reisebeginn war mir bewusst, dass ich diese Voraussetzung in Mali nicht als gegeben annehmen konnte: Mein Überallbüro musste auf schmale Bandbreiten und unzuverlässige Verbindungen vorbereitet werden.

Balast ablegen

Je weniger Gepäck man mitnimmt, desto unbeschwerter reist man und desto leichter kommt man mit Verlust zurecht. Dennoch kann der Verlust von wichtigen Dokumenten Schwierigkeiten verursachen. Aus diesem Grund habe ich meine Flugtickets, meinen Reise- und Impfpass und alle Medikamentenbeipackzetttel eingescannt und in Evernote gespeichert. So hätte ich im schlimmsten Fall digitale Kopien sowohl auf meinem Notebook als auch im Internet abrufen können.

Automatische Werkzeuge abschalten

Ich sammele mein Wissen, verwalte meine Arbeitsvorgänge und schreibe meine Notizen ausschließlich in Evernote. Dokumente aller Art speichere ich per Dropbox. Beide Programme synchronisieren Änderungen automatisch im Internet und stellen sie meinen anderen Computern zum Download bereit, sobald sie sich verbinden. Meine Adressdaten und Kalendereinträge verteile ich mit Hilfe von MobileMe auf meine Computer.

Diese im Hintergrund arbeitenden Werkzeuge erleichtern im Alltag meine Arbeit. Sie arbeiten so zuverlässig und transparent, dass man sie leicht vergisst. Es überraschte mich sehr, als alle drei Programme plötzlich die geringe Bandbreite im Internet-Café vollständig aufbrauchten. Deshalb ist es sinnvoll die automatische Synchronisation dieser Dienste abzuschalten und sie bei Bedarf manuell auszulösen.

Die drei Werkzeuge haben sich gerade nach meiner Rückkehr sehr bewährt. In wenigen Minuten waren meine Arbeit, meine Notizen, meine Photos und Kalendereinträge vom Notebook auf alle Rechner übertragen; ohne aufwändiges Heraussuchen und Kopieren von Hand.

Selbst im Urlaub gibt es etwas zu tun

Meine Aufgabenverwaltung übernimmt Remember the Milk, das ausschließlich eine Web-Benutzeroberfläche anbietet. Diese funktioniert bei guter Internet-Verbindung hervorragend, setzt diese aber auch für die Arbeit voraus. Um auch ohne Verbindung arbeiten zu können, bietet RTM in der kostenpflichtigen Variante mit Hilfe von Google Gears* einen Offline-Modus an. Aktiviert man ihn, so werden alle Aufgaben auf den Rechner kopiert und können fortan ohne bestehende Verbindung bearbeitet werden.

E-Mails

Was für reales Gepäck gilt, kann auch auf virtuelles Gepäck übertragen werden: Je weniger Ballast man hat, desto leichter ist die Übertragung. Um bei niedriger Bandbreite und schlechter Verbindung dennoch E-Mails lesen zu können, bündele ich alle meine E-Mail-Konten in einem einzigen Google Mail Konto. So muss ich nur eine einzige Webseite aufrufen, um meine E-Mails zu lesen. Da Google Mail ein Web-Interface hat, werden nur die Nachrichten übertragen, die ich wirklich lesen möchte. Große Dateianhänge oder Werbung kann ich überspringen.

Jedoch selbst das schlanke Google Mail Web-Interface kann auf Grund seiner Web 2.0 Fähigkeit dennoch zu schwerfällig sein. Hier kann man mit Preview aus Google Mail Labs und der HTML-Ansicht Abhilfe schaffen. Google Mail Labs bietet Zusatzfunktionen zu Google Mail an, die man einzeln aktivieren kann. Die Zusatzfunktion Preview zeigt den Inhalt des Posteingangs bereits an, während das Web-Interface noch geladen wird. So sieht man schnell, ob sich das vollständige Laden von Google Mail lohnt. Das Umschalten auf die HTML-Ansicht durch den Link unterhalb der Listenansicht im Web-Interface schaltet auf eine bandbreitenschonende, Javascript-lose Ansicht um.

Die Möglichkeit mit Filtern E-Mails zu markieren erlaubt es automatisch wichtige von weniger wichtigen E-Mails zu trennen. Man kann mit Filtern Labels vergeben und E-Mails mit einem Sternchen versehen, so dass wichtige E-Mails leicht aus der Menge neuer Nachrichten herausgefischt werden können.

Nachrichten

Newsfeeds mit RSS sind das Mittel der Wahl, um auch bei niedriger Bandbreite Nachrichten und Blogs lesen zu können. Mit dem passenden News Reader werden alle neuen Nachrichten vollständig geladen, so dass man sie in Ruhe offline lesen kann. Ich nutze dafür NetNewsWire, das Bilder und Videos nicht automatisch lädt und so die Bandbreite schont. Um auf dem Laufenden zu bleiben, genügen mir die Texte allemal.

Leider verbreiten viele Blogs ihre Inhalte nur auszugsweise per RSS und man muss doch die Webseite besuchen, um den ganzen Artikel lesen zu können. Dies fällt gerade auf Reisen mit langen Offline-Zeiten sehr negativ auf.

Strom sparen

Bleibt das Notebook längere Zeit ungenutzt, so ist hilfreich es entweder ganz auszuschalten oder anstatt “Suspend to RAM” “Suspend to Disk” zu nutzen. Dadurch bleibt die Batterie länger aufgeladen.

Fazit

Vorbereitung ist alles: Auch ohne ständige Internet-Verbindung kann das Überallbüro selbst in Mali genutzt werden. Die Flexibilität dort zu arbeiten, wo ich will, hat gerade in Mali zu neuen Ideen und Erkenntnissen geführt, die ich so nie in Deutschland, geschweige an einem festen Büroarbeitsplatz gehabt hätte. Das entspricht ganz dem, worauf uns Samuel Johnson aufmerksam machen wollte: Neue Perspektiven entdecken und die Welt mit anderen Augen sehen.

Und Du? Welche Vorbereitungen triffst Du, bevor Deine Reise beginnt, und welche Werkzeuge helfen Dir?

Verwandte Artikel:

*Google Gears kann man sich kostenlos bei Google herunterladen. Google hat die Entwicklung von Google Gears eingestellt, da der kommende HTML Standard (Version 5) die gleiche Funktionalität vorsieht. Bis dahin lässt sich Google Gears jedoch nutzen und RTM hat angekündigt, HTML5 einzusetzen, sobald die Browser-Hersteller es integriert haben werden.

★ Die ersten Schritte, oder vorausschauend arbeiten

Tue, 20 Apr 2010 15:10:00 GMT

"Die ersten Schritte bestimmen den ganzen Weg", so Arthur Schopenhauer. Diesem Zitat folgend ist es sinnvoll, sich zu Beginn einer neuen Aufgabe die ersten Teilschritte zu überlegen, bevor man mit der Arbeit beginnt.

Das Ziel meiner Aufgabenverwaltung ist es, meinen Geist von Ballast zu befreien. Indem ich alle Aufgaben aufschreibe, befreie ich mich von dem latenten Stress, etwas vergessen zu haben. Die konkrete Ausarbeitung von Teilschritten der Lösung gehört nicht in die Aufgabenverwaltung, sondern ist bereits Teil der Arbeit.

Vorausschauend arbeiten
Bevor ich mit der tatsächlichen Lösung beginne, überlege ich, welches die nächsten drei Teilschritte zur Lösung sind. Diese schreibe ich auf ein Post-It auf und klebe es direkt zwischen mich und meine Tastatur auf den Tisch. Auf diese Weise skizziere ich den Weg, den ich die nächsten Minuten oder Stunden gehen möchte. Ist ein Teilschritt abgeschlossen, streiche ich ihn durch.

Es passiert, dass mir während der Arbeit an einer Aufgabe einfällt, welche Teilschritte ich übersehen habe oder welche noch sinnvoll wären. Diese füge ich stets hinter den drei ursprünglichen Teilschritten auf dem Post-It hinzu. Es ist wichtig, die neuen Teilschritte am Ende einzufügen, damit man nicht “vom Hölzchen aufs Stöckchen” kommt und sich am Ende verzettelt. Der Fokus muss immer auf der ursprünglichen Aufgabe liegen und nicht auf einer perfekten Lösung für alle denkbaren Eventualitäten.

Sollte ich während der Bearbeitung unterbrochen werden, hilft mir das Post-It, dort wieder anzusetzen, wo ich unterbrochen worden bin.

Arbeitsprotokoll
Die gesammelten Post-Its geben mir am Ende meines Arbeitstages an, was ich tatsächlich abgearbeitet habe. Sie sind das Protokoll meiner Arbeit.

Versucht es selbst: Bevor Ihr eine neue Aufgabe angeht, überlegt, was die ersten Schritte zu einer Lösung sind. Schreibt sie auf und haltet Euch an den Fahrplan. Löst die Aufgabe für Euren spezifischen Kontext und vermeidet ausufernde, perfekte Allgemeinlösungen.

Verwandte Artikel:

★ Logbuch, oder wiederhole Dich nicht

Mon, 05 Apr 2010 08:00:00 GMT

Im Logbuch hält der Kapitän eines Schiffes alle wichtigen Ereignisse einer Fahrt fest. Dazu gehören unter anderem Kurs, Geschwindigkeit und Wetterlage. Die Funktion des Logbuches ist es, die Ereignisse an Bord nachzuhalten. Logbücher sind auf Handels- und Marineschiffen verpflichtend und gelten in juristischen Auseinandersetzungen als anerkanntes Beweismittel. Logbücher werden auch in anderen Fachgebieten eingesetzt. Bereits die ersten Computerpioniere führten Logbücher. Auf ein solches Logbuch geht der Begriff des Software-Bugs zurück. 1946 fand Grace Murray Hopper (engl.) nach einem Ausfall des Mark II eine Motte zwischen den Röhren des Computers. Zur Dokumentation der Ursache des Ausfalls klebte sie das tote Insekt in das Logbuch des Mark II.

Logbücher müssen aber nicht nur Ereignisse festhalten. In diesem Artikel stelle ich mein Ingenieurslogbuch vor, in dem ich gelöste Probleme festhalte. Stoße ich erneut auf das gleiche oder ein ähnliches Problem, kann ich mein Logbuch schnell zur Rate ziehen.

Don’t repeat yourself (DRY) — Wiederhole Dich nicht — ist ein Leitsatz aus der Software-Entwicklung. Es besagt, man solle den Aufwand für die Lösung eines Problems nur einmal treiben. Dieser Leitsatz lässt sich auf viele Aufgaben des täglichen Lebens übertragen. Insbesondere für uns Knowledge-Worker.

Ein Großteil der Arbeit von Knowledge-Workern besteht darin, Wissen zu sammeln um Probleme zu verstehen und zu lösen. Bücher, wissenschaftliche Fachartikel, Google, Blogs etc. sind die Quellen meines Wissen, das ich anpassen und anwenden muss, um ein konkretes Problem zu lösen. Bei diesem Vorgehen arbeite ich meist sehr zielorientiert. Ich identifiziere ein Teilproblem meiner Aufgabe, suche eine Lösung, passe sie an, baue sie in den Gesamtkontext ein und gehe zum nächsten Teilproblem über. Obwohl dieser Ansatz für ein konkretes Problem sehr gut funktioniert, ist er über mehrere Aufgaben und Probleme betrachtet ineffizient. Denn häufig ähneln sich Teilprobleme. Mir fällt dann bei der Recherche oft auf, dass ich etwas ähnliches schon einmal gemacht habe, aber ich weiß meist nicht mehr wo und wie.

Für diesen Zweck führe ich ein Ingenieurslogbuch, in das ich alle Lösungen eintrage: Wie erzeuge ich in Word ein geschütztes Leerzeichen? Wie erstelle ich eine automatische Abwesenheitsnotiz in Outlook? Wie koche ich ohne Reiskocher perfekten Sushireis?
All diese Fragen können im Internet beantwortet werden. So habe ich die Lösungen ja selbst gefunden. Aber muss ich noch einmal suchen, nachdem ich die Lösung bereits früher gefunden habe?

Das Logbuch führe ich in Evernote, so dass ich jederzeit und überall darauf zugreifen kann. Evernote sorgt selbstständig für die Synchronisation zwischen meinen Computern und meinem Mobiltelefon synchronisiert.

Jeder Eintrag in meinem Ingenieurslogbuch hat eine Kategorieüberschrift, eine kurze Beschreibung sowie einen Zähler. Der Zähler gibt mir die Auskunft, wie oft ich auf diesen Eintrag zugegriffen habe. Manchmal ist es auch sinnvoll den Link zur Quelle der Information zu speichern:

_Überallbüro — Problemlösungen effektiv festhalten: 1
__http://ueberallbuero.de/2010/04/logbuch-oder-wiederhole-dich-nicht/
_Halte die Lösungen für Teilprobleme in einem Logbuch fest. Dadurch vermeidest Du die Recherche wiederholen zu müssen, falls Du ein ähnliches Problem lösen musst.

Sind die Notizen zu einer Lösung zu lang, so erstelle ich eine eigene Notiz dafür und versehe sie mit dem Tag Engineer’s Log. Die Einträge sind nicht sortiert, sondern der neuste wird immer zu Beginn der Notiz eingefügt. Ich habe verschiedene Sortierungen ausprobiert. Jedoch bin ich zu dem Ergebnis gekommen, dass man für eine konkrete Suche immer eine andere Sortierung benötigt. Da Evernote alle Notizen volltextindiziert, kann man entweder nach der Beschreibung des Eintrages suchen oder man durchsucht das Dokument von oben nach unten. Gegenüber einer vollständig neuen Recherche mit Hilfe von Büchern, Google etc. kommt man so immer schnell ans Ziel.

Also, mach Dir keine doppelte und dreifache Arbeit, sondern investiere ein paar Minuten in Dein persönliches Logbuch, um bei nächsten Mal schnell und effizient Wiederholungen zu vermeiden.

Und Du? Wie verwaltest Du Dein Wissen? Nutzt Du spezielle Werkzeuge? Oder geht es Dir wie mir vor einiger Zeit und Du ärgerst Dich schon wieder nach den gleichen Begriffen bei Google suchen zu müssen? Kann man es besser machen als mit einem Logbuch? Schreib Deine Meinung in einem Kommentar!

Verwandte Artikel:

★ Ist Produktivität Zeitverschwendung, oder der erste Schritt zur Besserung

Mon, 22 Mar 2010 08:00:00 GMT

“Most of the time, trying to be productive is pointless” — zu deutsch, “Produktiv sein zu wollen, ist meistens sinnlos”. Dies behauptet Jonathan Mead im englischen Blog Illuminated Mind im Artikel “Why Trying to be Productive is a Huge Waste of Time”. Mead führt seine Feststellung auf die falsche Wahrnehmung, den falschen Stellenwert von Produktivität in unserer Gesellschaft zurück. Doch im Artikel “Prokrastination — ‘Morgen fang ich sicher an’” in der Online-Ausgabe der Zeitung “Die Zeit” werden Psychologen mit der Aussage zitiert, dass man versuchen muss produktiv zu sein, um nicht Gefahr zu laufen, der “Aufschieberitis” zu verfallen.

Auf diese widersprüchlichen Ansichten stieß ich in einem Kommentar zum Artikel “Fokussier dich! – Der Mythos und die Plage der Ablenkung” im Apple Mac Blog Apfelquak. Warum diese Positionen auf den zweiten Blick gar nicht so widersprüchlich sind und warum produktiveres Arbeiten uns mehr Zeit für erfüllende Lebensinhalte gibt, zeige ich in diesem Artikel.

“Die Bedeutung von Produktivität ist es, mehr Dinge in der gleichen Zeit zu tun.”, schreibt Mead, mit der Konsequenz, dass man aus den Augen verliere, was wirklich wichtig im Leben sei. “Ziele und Produktivität sind stark mit messbaren Ergebnissen verknüpft.” Solche Ziele würden leicht dazu verleiten, dass man bemüht sei, eben messbare Ergebnisse zu erreichen und dabei seine ursprüngliche Leidenschaft für die betreffende Tätigkeit verliere. Die wichtigen Dinge im Leben, wie das Verbringen von Zeit mit seinen Liebsten oder neue Lösungen für Probleme zu suchen, ließen sich weder quantifizieren noch planen.

Meads Antwort auf die widersprüchliche Bedeutung von Produktivität ist es, “dass man seinem Herzen folgt”. Es gehe nicht um die Ziele, die man erreicht, sondern um den Weg dort hin; das Leben im Jetzt, nicht das Leben, das man in Zukunft erreichen wolle.

Im Artikel der “Zeit online” wird die Frage gestellt, warum Menschen dazu neigen, Arbeit aufzuschieben und wie man sich von dieser Neigung befreien kann. “Menschen sind ökonomische Wesen und versuchen ihre Energie, sparsam einzusetzen”, wird Prof. Funke vom Psychologischen Institut der Universität Heidelberg zitiert. Aufschieben sei ein Selbstschutz. “Was man braucht, sind klare Arbeitsstrukturen und pragmatische Rituale. Auch wer meint, dass Arbeit immer Spaß machen muss, behindert sich selbst.”, so Rainer Holm-Hadulla, Leiter der Psychotherapeutischen Beratungsstelle der Universität Heidelberg. “Wichtig ist aber auch das Ausschalten von Störfaktoren. Telefon ausschalten, Fernbedienung weglegen und E-Mail-Programm schließen — anders geht es nicht.”, meint dazu Diplom-Psychologe Hans-Werner Rückert.

Ist Produktivität nun Zeitverschwendung?

Soll man nun darauf hoffen, dass man automatisch produktiv wird, wenn man seinem Herzen folgt und die Dinge tut, die einem wichtig sind, oder versuchen, seine Produktivität durch Produktivsysteme und passende Werkzeuge zu steigern?

Meine Antwort auf diese Frage ist, dass man produktiver sein sollte, um Zeit für die Dinge freizumachen, die uns glücklich machen. In der Tat besteht das Leben in unserer Gesellschaft nicht nur aus Spaß und Freude. Sich mit der GEZ über Gebühren zu streiten, Rentenversicherungen abzuschließen oder Altglas wegzubringen, sind nur einige Beispiele für Arbeiten, die keinen Spaß machen, aber getan werden müssen. Deswegen ist es auch so wichtig, den Sinn und Zweck einer Aufgabe klar festzuhalten, damit man weiß, warum man die Aufgabe lösen möchte und sie kein unmotivierender Selbstzweck bleibt.

Manche Aufgaben liegen uns nicht am Herzen, aber müssen trotzdem erledigt werden. Jedoch können wir beeinflussen, wie wir mit ihnen umgehen: Effizient und effektiv, indem wir sie angehen und erledigen, oder durch Aufschieben und Hoffen, dass sie sich von selbst erledigen.

Mein Ziel ist es, Zeit sinnvoll zu nutzen. In meinem Verständnis von Arbeitsproduktivität geht es nicht darum, immer mehr, immer schneller zu machen. Es geht darum, die vorhandene Zeit sinnvoll einzusetzen. Deswegen versuche ich, meinen Tag vernünftig zu planen, meine Arbeit effektiv und konzentriert zu erledigen, um eben freie Zeit für Gedanken, Freunde und spaßige Dinge zu haben. Ich habe irgendwann während meines Studiums erkannt, dass die unangenehmen Aufgaben des Lebens nicht von alleine verschwinden. Jedoch kann ich durch ein aktives Herangehen dafür sorgen, dass sie mich nicht übermäßig belasten. Indem ich sie zeitnah erledige, liegen sie nicht ewig in meinem Kopf und erzeugen unnötigen Stress.

Wie erreicht man seine Ziele?

Bleibt aber die Frage, wie man das Aufschieben beendet und seine Arbeit erledigen kann. Die beste Antwort darauf, bekam ich von einem guten Freund, als ich mit meiner Promotion fest steckte: “Fang an, mach den ersten Schritt.” Dieser simple Satz ist schwerer umgesetzt als ausgesprochen, jedoch die Essenz aus allen Produktivsystemen, Büchern und Vorträgen, die es zu diesem Thema gibt. "Die Pyramiden sind auch nicht an einem Tag erbaut worden", aber die Arbeiter des Pharaos haben an einem Tag den ersten Stein gesetzt, den ersten Schritt gemacht.

Falls Du nicht weiter kommst, eine unangenehme Aufgabe vor Dir herschiebst, dann nimm Dir ein leeres Blatt Papier und schreibe sie auf. Überleg, was als aller erstes getan werden muss, damit sie irgendwann erledigt werden kann und dann tu es! Wenn dieser erste Schritt erledigt ist, schreib den nächsten Schritt auf und arbeite an ihm. Schieb es nicht mehr auf, sondern tu es jetzt, mach den ersten Schritt. Wie beim Sport, ist das Hinfahren, Umziehen und Aufwärmen das schlimmste. Hat man aber erst mal begonnen, geht es fast wie von selbst.

Du hast es in der Hand, also fang an!

Was sind Deine Erfahrungen zum Thema Produktivität? Fühlst Du Dich gezwungen immer produktiver zu sein und vermisst Du die guten Dinge im Leben? Oder hast Du den Weg gefunden, Arbeit und Freude in Deinem Leben zu vereinbaren?

Verwandte Artikel:

★ F.lux, oder es werde richtiges Licht

Mon, 08 Mar 2010 08:00:00 GMT

Grok (engl.) ist der Stellvertreter unserer urzeitlichen Vorfahren, der häufig für die Steinzeiternährungsweise in Anschaungsbeispielen benutzt wird. Die Steinzeiternährungsweise verfolgt den Ansatz, dass wir eher die Kost unserer Vorfahren nachahmen und auf die Entwicklungen des Ackerbaus der letzten 10.000 verzichten sollten. Sie sollte zusätzlich mit sportlicher Belastung kombiniert werden, die den körperlichen Belastungen unserer Vorfahren entsprechen. Hält man sich an diese Lebensweise, sollen Zivilisationskrankheiten wie Diabetes, Fettleibigkeit etc. verhindert werden.

In Groks Leben gab es keine Computer und künstliche Lichtquellen. Er stand auf, wenn die Sonne aufging, und legte sich vor wilden Tieren durch sein Lagerfeuer beschützt schlafen, nachdem die Sonne untergegangen war. Im Gegensatz zu Grok können wir dank Wecker und elektrischen Lampen aufstehen und schlafen gehen, wann wir es wollen. Jedoch reagieren wir laut Schlafforschung nach wie vor genauso auf die Farbzusammensetzung von Licht wie unser Vorfahre Grok*****.

Wie man damit im Überallbüro umgeht und die Belastung seiner Augen durch Bildschirmarbeit verringert, zeigt dieser Artikel.

Halogen- und Energiesparlampen emittieren kaltes Licht mit hohen Anteilen an blauem Licht. Dies trifft ebenfalls auf Fernseher und Monitore zu. Grundsätzlich gilt, je höher die Farbtemperatur desto größer ist der Anteil an blauem Licht. Studien (engl.) aus der Schlafforschung haben gezeigt, dass die Melatoninproduktion abhängig vom Tageslicht ist und stark mit dem Blauanteil des Tageslichts zusammenhängt. Melatonin ist unser innerer Zeitgeber und für unseren Tag- und Nachtrhythmus verantwortlich.

Die Vorzüge des Überallbüros erlauben es uns zu arbeiten wann und wo wir wollen. Insbesondere können wir dann arbeiten, wenn wir uns am produktivsten fühlen. Dies kann mal frühmorgens vor Sonnenaufgang oder spätabends nach Sonnenuntergang sein. Jedoch beeinflusst der Blauanteil des Lichtes unserer Monitore die Melatoninproduktion in unserem Körper. Wir fühlen uns abends bei blauem Licht wacher (engl.) als zum Beispiel bei Kerzenlicht.

Ein weiterer Effekt ist, dass blaues Licht währen der Schlafenszeit unsere Augen stärker anstrengt als tagsüber. Ich stelle manchmal fest, dass morgens während ich meinen Tag vorbereite und es draußen noch dunkel ist, meine Augen vom Licht des Monitors brennen. Genauso ergeht es mir manchmal abends, wenn ich Nachrichten und letzte E-Mails lese. Dies lässt sich auf unseren Tag- und Nachtrhythmus zurückführen, denn unsere Augen werden vom blauen Licht überrascht, während unser Gehirn auf Schlafenszeit eingestellt ist.

Die Macher von F.lux treten mit ihrem Hilfsprogramm diesem Umstand entgegen, indem F.lux die Farbtemperatur des Bildschirms automatisch an die tagesaktuellen Sonnenauf- und -untergangszeit anpasst, so dass das Licht wärmer und damit für die Augen angenehmer wird (s. Bilder unten). F.lux steuert die Anpassung der Farbtemperatur über einen Zeitraum von einer Stunde, um zu verhindern, dass man plötzlich von der Umstellung überrascht wird. Natürlich ist dieser Farbmodus nicht für jede Tätigkeit geeignet. Bearbeitet man Bilder oder schaut einen Film, so ist man auf die korrekte Darstellung von Farben angewiesen. Dafür lässt sich F.Lux per Mausklick für eine Stunde aussetzen, um mit der normalen Farbeinstellung weiterzuarbeiten. F.lux ist kostenlos und sowohl für Windows, Mac OS X als auch für Linux verfügbar.

http://ueberallbuero.de/wp-content/uploads/2010/03/Flux_kalt.png http://ueberallbuero.de/wp-content/uploads/2010/03/Flux_warm.png

Es ist ein bisschen überraschend, wie gut F.lux funktioniert. Wenn ich morgens am Rechner meine Termine und Aufgaben des Tages durchsehe, so gewöhnen sich meine Augen viel schneller und leichter an Licht als mit der normalen Farbeinstellung.

Probiert es aus. Versucht eure Augen gemäß unserer Veranlagung an das richtige Licht zur richtigen Zeit zu gewöhnen und berichtet hier auf Überallbüro über Eure Erfahrungen.

Verwandte Artikel:

Fokus, oder immer dran bleiben

* Dies lässt sich in einem kleinen Selbstversuch leicht nachvollziehen: Ich schalte meinen Computer und meine Halogenlampen mindestens 30 Minuten bevor ich schlafen gehe aus. Damit gebe ich meinen Augen bzw. meinem Gehirn die Möglichkeit, mit der Melatoninausschüttung zu beginnen, bevor ich im Bett liege. Seitdem fällt es mir viel leichter einzuschlafen als früher. Probiert es aus!

★ Schlaue Ziele, oder Aufgaben mit Fingerspitzengefühl

Mon, 22 Feb 2010 08:00:00 GMT

Fingerkraft ist beim Klettern in vielen Situationen entscheidend. Manche Griffe sind klein oder liegen ungünstig, so dass nur mit ausreichender Kraft in den Fingern ein sicherer Halt möglich ist. Die Kraft geht dabei nicht nur von der Fingermuskulatur, sondern auch von den Unterarmen aus. Um diese Muskulatur zu trainieren, kann man sich ein Fingerbrett (Fingerboard engl.) kaufen; oder selbst bauen.

Anhand meines selbstgebauten Fingerbretts zeige ich in diesem Artikel, wie man Aufgaben mit Hilfe von SMART effektiv entwickelt. Durch SMART verlieren Aufgaben ihren Schrecken und die eigene Motivation sie zu lösen steigt.

Specific Measurable Achievable Relevant Timely Goals ([SMART](http://de.wikipedia.org/wiki/SMART_(Projektmanagement ‘SMART bei Wikipedia’), zu deutsch Spezifische, Messbare, Angemessene, Realistische, Terminierte Ziele) stammt aus dem Projektmanagement. Es wurde ursprünglich von George Doran u.a. 1981 vorgestellt [1]. Wie das ausgeschriebene Akronym besagt, sollte eine Aufgabe stets klar formuliert, die Erfüllung messbar, Kosten und Nutzen angemessen, realistisch lösbar und zeitlich festgelegt sein.

Ich erweitere meine Aufgaben häufig noch um einen Nutzen, einen Zweck, welcher sich für mich ergibt, sobald die Aufgabe gelöst worden ist. Dies erhöht meine Motivation die Aufgabe auszuführen, da ich stets weiß, warum ich sie mache; oder ich verwerfe sie, wenn mir der Zweck nicht mehr sinnvoll erscheint.

Klar formuliert

Fingerbrett schrieb ich als erstes in mein Notizbuch als ich mich entschied, meine Fingerkraft zu verbessern. Für eine schnelle Notiz ist dies sicherlich ausreichend, aber als ich am Abend meine Notizen durchging, übertrug ich jedoch etwas mehr in mein Aufgabenverwaltungssystem, damit ich noch einige Tage, Wochen später weiß, was ich ursprünglich damit gemeint habe:

Bau ein Fingerbrett.

Erfüllung messbar

Was genau will ich eigentlich bauen und wann ist es fertig? Ich möchte zwei Dinge trainieren, nämlich kleinere Griffe zu halten und in schwierigen Situationen Klimmzüge machen zu können. Dafür brauche ich Griffe unterschiedlicher Größe und unterschiedlicher Entfernung. Ähnlich zur Anordnung auf dem Bild [2] habe ich mich für vier übereinander liegende Leisten entschieden: zwei 4,5 cm tief und zwei 2 cm tief. Damit ist klar feststellbar, wann mein Fingerbrett fertig ist und es wird nicht zu einer endlosen, immer wieder aufgeschobenen Aufgabe:

Bau ein Fingerbrett mit vier Leisten (2x 4,5 cm, 2x 2 cm).

Kosten und Nutzen angemessen

Man kann für beliebig viel Geld fertige Fingerbretter kaufen oder spezielles Holz etc. für den Selbstbau nutzen. Ich wollte insgesamt nicht mehr als 50 Euro ausgeben. Im Baumarkt habe ich ein 40x60 cm^2 großes Brett aus geleimten Massivholz für 10 Euro als Rest einer Küchenarbeitsplatte gefunden sowie zwei Kanthölzer in den passenden Größen. Dazu kamen noch Spax-Schrauben und Betonschrauben mit Stahldübeln:

Bau ein Fingerbrett mit vier Leisten (2x 4,5 cm, 2x 2 cm) für 35 Euro.

Realistisch lösbar

Trainieren möchte ich zu hause zwischendurch, deshalb sollte das Fingerbrett über die Tür passen. Die Baumaterialien hatte ich gekauft und Bohrmaschine mit Holz- und Betonbohrer im Keller. Damit war alles zusammen, um das Brett wirklich zu bauen:

Bau ein Fingerbrett mit vier Leisten (2x 4,5 cm, 2x 2 cm) für 35 Euro und häng es über die Schlafzimmertür.

Zeitlich festgelegt

Das Fingerbrett sollte letztes Wochenende gebaut werden:

Bau am Samstag ein Fingerbrett mit vier Leisten (2x 4,5 cm, 2x 2 cm) für 35 Euro und häng es über die Schlafzimmertür.

Nutzen und Zweck

Wie am Anfang beschrieben, möchte ich schwierige Griffe in der Wand halten können, die es mir zur Zeit schwer machen:

Bau am Samstag ein Fingerbrett mit vier Leisten (2x 4,5 cm, 2x 2 cm) für 35 Euro und häng es über die Schlafzimmertür, um kleine Griffe besser halten zu können.

Diese Aufgabenformulierung scheint sperrig und unhandlich formuliert zu sein, jedoch ist sie tatsächlich umsetzbar und ich weiß, warum ich sie umsetzen will. Jedes Mal, wenn ich sie lese, kann ich fundiert entscheiden, ob sie ausgeführt werden soll.

Theorie und Praxis

SMART lässt sich wie viele theoretische Konzepte nicht eins zu eins in die Praxis übertragen. Häufig weiß man bei einer neuen Aufgabe gar nicht, wie die einzelnen Aspekte von SMART auszufüllen sind. Insbesondere die Aspekte realistisch lösbar sowie Kosten und Nutzen sind nicht immer Teil einer Aufgabenbeschreibung. Entsprechende Überlegungen sollten jedoch zur Planung und Ausführung von Aufgaben gehören, auch wenn sie nicht ausformuliert in die Aufgabenverwaltung aufgenommen werden. Ähnlich wie in der Fingerbrettaufgabe, entwickele ich Aufgaben über die Zeit weiter. Umso näher ihre Umsetzung rückt und je mehr ich über sie weiß, desto klarer und präziser werden die Formulierungen.

Grundsätzlich sollte man bei jeder neuen Aufgabe die SMART-Aspekte im Hinterkopf behalten und sie sukzessive in die Aufgabe einpflegen. Auf diese Weise werden Aufgaben leichter umsetzbar und sie verlieren ihre Schrecken. Wenn ich weiß, was genau getan werden muss, wann ich fertig sein werde und warum ich sie machen möchte, ist eine Aufgabe kein graues, schwammiges Etwas mehr, das kaum überwindbar scheint und auf das ich einfach keine Lust habe.

Setze diese Woche SMART ein und berichte in den Kommentaren, wie Du damit zurecht kommst. Klappt es gut oder schlägt es fehl, die einzelnen Aspekte mit Inhalt zu füllen? Schreibe mir Deine Beispiele und Probleme.

Verwandte Artikel:

[1] Doran, George T. “There’s a S.M.A.R.T. way to write managements’s goals and objectives.” and Miller, Arthur F. & Cunningham, James A “How to avoid costly job mismatches” Management Review, Nov 1981, Volume 70 Issue 11

[2] Bildquelle: http://jamespearsonclimbing.blogspot.com/

★ Entschleunigung, oder langsam schneller ans Ziel

Mon, 08 Feb 2010 09:30:00 GMT

“In der Ruhe liegt die Kraft”, “Eile mit Weile” und “Eile ist die Tüchtigkeit von Stümpern” sind Redensarten, die eines gemeinsam haben. Sie drücken aus, dass man sich Zeit nehmen und nicht hetzen soll, sondern versuchen soll seine Aufgaben in Ruhe anzugehen.

Das klingt vernünftig und doch halten wir uns bei der täglichen Arbeit nur selten daran. Ich erlebe es bei mir selbst. Wenn die Tagesaufgaben kaum zu bewältigen sind, der Stress steigt, beginne ich mehrere Sachen gleichzeitig zu bearbeiten und werde ungeduldig. Klappt eine Aufgabe nicht auf Anhieb, springe ich zur nächsten und versuche dort mein Glück. Am Ende des Tages habe ich dann meist nichts wirklich erledigt und gehe unbefriedigt mit einem schlechten Gefühl nach Hause.

Carl Honoré beschreibt dieses Verhalten ausführlich in seinem inspirierenden Ted-Talk*. Er bricht das Tabu und verordnet sich Langsamkeit. Ein Wort, dass seiner Meinung nach in unserer Gesellschaft tabuisiert werde. Langsamkeit sei ein Stigma für schlecht.

Er weißt aber zurecht darauf hin, dass Langsamkeit bzw. Ruhe die Grundlage für Kreativität ist. Erst wenn man seinem Geist Zeit gibt, über ein Problem nachzudenken, findet er neue Ansätze und unbekannte Lösungsideen. Diese Ruhe müssen wir Knowledge-Worker in unserem täglichen Leben suchen und anwenden.

Im Grunde genommen wissen wir das instinktiv. Man kann nicht in 2 Wochen 15 kg abnehmen, 15 kg Muskelmasse zulegen oder für einen Marathon trainieren. Genauso wie körperliche benötigen geistige Herausforderungen Zeit insbesondere dann, wenn eine effektive, langanhaltende Lösung gefunden werden soll.

Natürlich ist es schwer abzuschalten, den Stress abzuschütteln und uns zu erlauben, ohne sofortige Ergebnisse nachzudenken. Aber nur so gelingt es uns, eine Fragestellung aus unterschiedlichen Perspektiven zu betrachten. Es ist auch die Zeit, die unser Gehirn benötigt, um in unseren Erfahrungen und Erkenntnissen nach ähnlichen Problemen zu suchen, um so neue, kreative Lösungen vorzuschlagen (seht dazu das Buch “Pragmatic Thinking and Learning: Refactor Your Wetware”).

Also traut Euch, entschleunigt Eure Arbeit und findet bessere als nur die erstbesten Lösungen. Versucht es diese Woche selbst bei einem Problem, das Euch schon längere Zeit beschäftigt. Setzt Euch in Ruhe hin und lasst Euren Gedanken für eine Stunde freien Lauf. Nehmt ein Blatt Papier, schreibt das Problem auf und konzentriert euch nur darauf. Ihr werdet bestimmt eine Lösung finden, die Euch überrascht!

Das Video von Carl Honorés Vortrag über das “Slow-Movement” und die positiven Effekte der Langsamkeit und Ruhe auf Euer ganzes Leben könnt Ihr Euch hier ansehen.

Und Du? Entschleunigst Du noch oder arbeitest Du schon in Ruhe? Berichte über Deine Erfahrungen oder folge meiner Aufforderung und beschreibe, ob Langsamkeit Dir in dieser Woche geholfen hat.

* Die Technology, Entertainment, Design (TED) Conference ist eine alljährlich stattfindende Konferenz, während der sich die einflussreichsten Menschen der Welt austauschen. Dazu werden Gäste aus den unterschiedlichsten Fachgebieten geladen, um Vorträge zu halten. Diese Vorträge werden über das Jahr veröffentlich. Wer TED noch nicht kennt, dem kann ich nur empfehlen sich von den faszinierenden Vorträgen inspirieren zu lassen.

★ Konzentration, oder nicht ablenken lassen

Mon, 25 Jan 2010 08:00:00 GMT

Ich habe viel Spaß beim Sportklettern. Nach einem langen Arbeitstag hilft es mir abzuschalten und mich zu entspannen. Dies gilt im wahrsten Sinne des Wortes: Als Knowledge-Worker sitze ich den ganzen Tag sehr viel, wodurch meine Muskeln verspannen. Die ganzheitliche Bewegung beim Klettern lockert sie wieder auf.

Der Erfolg beim Klettern hängt von zwei primären Faktoren ab, 1. der Klettertechnik und 2. dem eigenen Willen. Natürlich braucht man auch Kraft und Beweglichkeit, jedoch erst die richtige Klettertechnik erlaubt es, diese richtig einzusetzen. Hängt man an einer schwierigen Stelle in der Wand, ist es oft die Willenskraft, die über den Erfolg des nächstens Zugs entscheidet. Es ist überraschend, aber oft geht mehr als man für möglich hält.

Bei der täglichen Arbeit sind es wieder die beiden Faktoren Technik und Willen, die über den Erfolg des Arbeitstages entscheiden. Wir Menschen neigen dazu, uns leicht ablenken zu lassen*****. In diesem Artikel möchte ich meine Art beschreiben, wie ich meine Aufmerksamkeit auf die Arbeit konzentriere und Ablenkungen widerstehe. Es ist wie beim Klettern: Mit der richtigen Technik und Willen, geht mehr als man denkt.****

Aufmerksamkeit

Professor Dr. Werner Stangl definiet Aufmerksamkeit “als die primäre Ressource der Informationsgesellschaft, denn sie ist ein Auswahlverfahren. Es wird ausgewählt, was man wahrnimmt, was also ins Bewußtsein kommt, und was nicht.” Im Artikel In Defense of Distraction (engl.) stellt Sam Anderson fest, dass wir eigentlich immer aufmerksam sind, jedoch schweift unsere Aufmerksamkeit leicht von einer Sache zur nächsten ab. Durch das Lenken unserer Aufmerksamkeit entscheiden wir, was wir mit unserer Arbeitszeit machen möchten. Nur wenn wir sie auf unsere Aufgaben lenken, erreichen wir unsere Ziele.

Aufmerksamkeitsverlust

In meinem täglichen Leben stelle ich zwei Quellen für den Verlust meiner Aufmerksamkeit fest. Die externe Ablenkung wird durch äußere Reize ausgelöst: E-Mails, Telefonanrufe, Nachrichten-Webseiten, Gegenstände auf meinem Tisch, oder Geräusche auf der Straße. Die interne Ablenkung geschieht in meinem Kopf. Wann immer ich beginne mich zu langweilen, schießen mir Ideen in den Kopf. Wann immer ein Problem zu schwierig wird, zieht es mich zu leichteren Aufgaben oder wieder einmal zu meinen beliebtesten Web-Seiten.

Aufmerksamkeitserhalt

Man muss sich klar machen, dass wir nicht alle Quellen der Ablenkung beeinflussen können. Das menschliche Gehirn mag Ablenkung. Es ist darauf programmiert, ständige neue Reize wahrzunehmen und zu verarbeiten. Es ist nicht unsere Natur, abgeschottet von den Ereignissen um uns herum, nur an einer Aufgabe zu arbeiten. Aber es liegt sehr wohl in unserer Macht, unsere Programmierung zu hacken und zumindest für eine gewisse Zeit konzentriert den Reizen der Umwelt zu widerstehen.

Drei Schritte zur Aufmerksamkeit

Der erste Schritt ist es, die externen Ablenkungsquellen zu minimieren. Ich schalte dafür alle Internet-Dienste und mein Telefon aus. Es ist nicht der Fehler der modernen Technologien, sondern unser mangelnder Wille, wenn wir uns von ihr ablenken lassen. Meinen Schreibtisch räume ich oft vor einer neuen Aufgabe auf, um auch hier die Ablenkungsquellen zu minimieren. Das Ziel dieser Dämpfung der äußeren Welt ist es, einen ruhigen Wesenszustand zu erreichen, in dem alles auf die geplante Aufgabe fokusiert ist. Dennoch gelingt es mir nicht immer, diesen Zustand zu erreichen. In diesem Fall wechsele ich meinem Arbeitsplatz: Das Überallbüro kann ich zum Glück an jeden Ort mitnehmen; mal arbeite ich in meinem Büro, dann wieder an meinem Schreibtisch zu hause oder in der Universitätsbibliothek. Ich arbeite dort, wo ich mich am Besten konzentrieren kann.

Der zweite Schritt befasst sich mit den internen Ablenkungen. Wenn ich ein Buch lese oder nachdenke, kommen mir Gedanken zu ganz anderen Problemen. Plötzlich fällt mir der Bandname ein, auf den ich gestern nicht kommen konnte. Dies ist keine Aufmerksamkeitsstötung, sondern die Art und Weise, wie unser Gehirn arbeitet. Während wir konzentriert an einer Aufgabe arbeiten, beschäftigt sich das Gehirn im Hintergrund noch mit anderen Dingen. Entscheidend ist es, wie man mit diesen Ablenkungen umgeht. Es ist ein Fehler, jedem Gedanken nachzujagen und seine Arbeit zu unterbrechen. Ich habe stets ein kleines Notizuch oder einen Stapel Post-Its bei mir , mit denen ich diese Geistesblitze festhalte: Schnell aufschreiben und nicht ablenken lassen. Später komme ich auf sie zurück.

Der dritte Schritt ist die Überwindung von Hindernissen bzw. Langeweile. Versuche ich einen schwierigen Algorithmus zu verstehen, schweit mein Gehirn gerne ab. Es hat keine Lust auf anstrengende Aufgaben und denkt lieber über etwas anderes nach. Wann immer mir dies auffällt, stelle ich mir die Frage: “Muss ich jetzt darüber nachdenken, kann ich das später machen?” Wie beim Klettern, ist es eine Frage des Willens über sich hinauszuwachsen und seine Gedanken in die richtige Richtung zu lenken. Dies ist der schwierigste Schritt, aber sich bewusst machen, dass man sich gerade ablenkt, ist der richtige Weg. Anhalten, Durchatmen, allen Gedanken im Kopf kurz folgen und sich dann wieder gezielt seiner Aufgabe zuwenden. So versuche ich meinen Willen durchzusetzen.

Es ist aber auch wichtig zu verstehen, dass aufmerksames Arbeiten anstrengend ist und Kraft kostet. Wir können das nicht den ganzen Tag durchhalten. Aus diesem Grund ist es wichtig, seine produktivste Arbeitszeit des Tages, konsequent für die wichtigste Aufgabe des Tages zu nutzen. Dies plane ich regelmäßig am Abend für den nächsten Tag.

Aufmerksamkeitskarte

In der Aufmerksamkeitskarte habe ich die wesentlichen Punkte zusammengefasst. Ihr könnt sie ausdrucken und auf Euren Tisch stellen. Schaut sie immer an, wenn ihr merkt, dass Eure Aufmerksamkeit ungewollt verloren geht und findet den Weg zurück zu konzentriertem Arbeiten.

Es ist die Technik und die mentale Willenskraft, die ausschlaggebend sind. Sie entscheiden darüber, ob wir unsere Aufgaben bewältigen oder von einer Sache zur nächsten schweifen. Es ist nicht leicht, die angesprochenen Ansätze umzusetzen. Ich probiere es dennoch jeden Tag und versuche wie beim Klettern über mich herauszuwachsen. Das könnt Ihr auch!

Und Du? Ist konzentriertes Arbeiten für Dich ein Problem oder hast Du schon längst Deinen eigenen Weg zu mehr Aufmerksamkeit gefunden? Lass die anderen Leser teilhaben und schreib einen Kommentar!

Verwandte Artikel:

* Man kann dies in einem kurzen Experiment ausprobieren: Nehmt ein leeres DIN-A4 Blatt Papier und malt mit meinem Stift einen Punkt darauf. Seht auf die Uhr und merkt Euch die Zeit. Nun konzentriert Euch auf nur auf den gemalten Punkt. Wie lange haltet Ihr es durch, ohne mit Euren Gedanken abzuschweifen oder sogar weg zu blicken?

★ Geregelte E-Mail-Zeiten, oder Mythen der Organisation

Thu, 07 Jan 2010 18:37:00 GMT

Homer Simpsons Fähigkeiten effizient zu arbeiten habe ich bereits mehrfach als leuchtendes Beispiel auf ueberallbuero.de beschrieben. Eine ganz besondere ist seine Konzentrationsfähigkeit. Homer gelingt es auf geradezu zen-buddistische Art jegliche äußeren Reize zu ignorieren. Dies spiegelt sich schon in einfachen Zitaten von Homer wieder: “Kann nicht sprechen … esse” oder “Kann Familie nicht töten … esse”.

Mir fehlt diese Stärke und so muss ich mich täglich neu überwinden konzentriert zu arbeiten. Doch wie geht das in Zeiten von E-Mail und Instant-Messaging? Oft lese ich den Ratschlag, diese Reizquellen nur zu geregelten Zeiten zuzulassen, wie zum Beispiel in dem Blog von David Gerlach und Angelika Stein “Die Ordnungsprofis”. Sie schlagen vor, nur morgens, mittags und eine Stunde vor Feierabend E-Mails zu bearbeiten.

Ich glaube, diese Strategie greift zu kurz und ist im Überallbüro unrealistisch. Wieso und wie man dennoch konzentriert an einer Aufgabe arbeiten kann, zeige ich in diesem Artikel.

http://ueberallbuero.de/wp-content/uploads/2010/01/mail_dock.png

Die Realität

Es ist natürlich richtig, sich nicht permanent von neuen E-Mails ablenken zu lassen. Jedoch ist es selten mit dem bloßen Lesen einer E-Mail getan. Häufig enthalten E-Mails Handlungsaufforderungen, die nicht in kurzer Zeit bearbeitet werden können. E-Mails der Art “Welche Kundennummer hat Herr Mustermann” sind eher eine Seltenheit für Knowledge-Worker. Viele E-Mails kann ich erst nach einiger Recherche, Nachdenken oder Gesprächen mit Kollegen beantworten.

Aber E-Mails haben für uns Knowledge-Worker eine Bedeutung über bloße Nachrichten hinaus. Im E-Mail-Archiv sind viele Informationen gespeichert, auf die man während der täglichen Arbeit zugreifen muss. Ein Abschalten des E-Mail-Programms kommt damit nicht in Frage. Ferner vernetzen uns E-Mails und in zunehmende Maße auch Instant-Messaging uns mit der äußeren Welt. Wir können viele Aufgaben nicht mehr unabhängig von unseren Kollegen lösen. Auch deswegen ist es schwierig, das E-Mail-Programm gänzlich zu schließen.

Nicht ausreichende Strategie

Würde ich der vorgeschlagenen Strategie folgen, nur morgens, mittags und abends E-Mails zu bearbeiten, so wäre vermutlich schon nach dem morgendlichen E-Mail-Check mein Vormittag blockiert — und vormittags bin ich am produktivsten. Zusätzlich führt sie am tatsächlichen Problem vorbei. Es gibt neben E-Mails auch noch Telefon, SMS, Chat, Kollegen, die ein und aus gehen etc.

Persönliche Disziplin

Der 3x-am-Tag-Ansatz mag vielen helfen, die jeden Tag ähnliche E-Mails und Aufgaben bearbeiten, jedoch gelten für uns Knowledge-Worker andere Bedingungen. Wir müssen kommunizieren, wir fragen nach, wir tauschen uns aus und warten auf die eine wichtige E-Mail, um die aktuelle Aufgabe beenden zu können. Dies kann nicht nach dieser Strategie erfolgen.

Diese und ähnliche Strategien versuchen meinst etwas zu ersetzen, das viel hilfreicher, aber schwerer einzusetzen ist: Disziplin. Die Selbstdisziplin zu Widerstehen, jedem neuen Reiz nachzujagen ist zwar schwieriger, aber weitaus effektiver und für alle Arten von Störungen hilfreich.

Offline Welt

Der Grundgedanke des 3x-am-Tag-Ansatzes ist dennoch richtig. Möchte man sich voll und ganz einer Aufgabe widmen, so ist es oftmals hilfreich, Störquellen zu beseitigen und einfach mal offline zu sein. Jedoch sollte dies nicht nach einer starren Regel erfolgen, sondern unserer persönlichen Arbeitsweise entsprechen, wo und wann man es gerade braucht.

Auf diese Weise ist auch dieser Artikel entstanden: Zuerst sammelte ich alle notwendigen Bilder und Notizen, übertrug sie in eine neue Evernote-Notiz und schrieb danach dediziert in der Offline-Welt.

PS Ich schalte die Anzeigen der Anzahl ungelesener E-Mails in meinem E-Mail-Programm ab, so dass die Versuchung nachzuschauen gering bleibt.

Und Du? Wie beugst Du der Ablenkung durch E-Mails etc vor? Welche Software hilft Dir ? Lass die anderen Leser teilhaben und schreib einen Kommentar!

Verwandte Artikel:

★ Das Archiv, oder wie man E-Mails nicht organisiert

Tue, 24 Nov 2009 16:21:00 GMT

Das Parkinsonsches Gesetz besagt, dass die Zeit zum Erledigen einer Aufgabe mit der dafür zur Verfügung stehenden Zeit wächst. Zu dieser überraschenden Erkenntnis kam der Soziologe Cyril Northcote Parkinson bereits während der vierziger Jahre des letzten Jahrhunderts. Eine direkte Ableitung seines Gesetzes besagt, dass die Verwaltung einer Organisation die Tendenz habe, beliebig zu wachsen. Ab einem gewissen Punkt beschäftigt sich die Verwaltung ausschließlich mit sich selbst: Sie erzeugt und verschiebt nur noch eigene Aktenstapel und ist damit voll ausgelastet.

Wenn ich meinen täglichen E-Mail-Eingang betrachte, so habe ich manchmal das Gefühl, Teil einer solchen Verwaltung zu sein. E-Mails sind schnell, billig und unidirektional. Es ist viel leichter, eine E-Mail zu schicken als selbst nachzudenken, selbst zu recherchieren und sogar selbst zu entscheiden. Dennoch sind E-Mails ein sehr nützliches Werkzeug und mit der Zeit entsteht in jedem Postfach eine beträchtliche Wissensdatenbank. Doch wie organisiert man diese Wissensdatenbank, wie zapft man sie schnell an? In diesem Artikel stelle ich vor, wie ich meine E-Mails verwalte, ohne den Überblick zu verlieren.

Früher habe ich versucht, diese Fragen mit Ordnern zu beantworten. Für meine Kunden, meine Freunde, meine Kochrezepte, meine Service-Anfragen etc. gab es jeweils einen Order, in dem ich jede E-Mail nach der Bearbeitung einsortiert habe. Suchte ich ein Kochrezept, so konnte ich direkt im dazugehörigen Ordner nachschauen.

Diese Ordnerstruktur neigt jedoch dazu zu wachsen und mit zunehmender Anzahl an E-Mails sucht man immer länger. Die liegt daran, dass dieser Ordnungsansatz von zwei falschen Annahmen ausgeht:

1. E-Mails lassen sich genau einer Kategorie zuordnen.
2. E-Mails behandeln immer nur ein einziges Thema

Gehört ein Kochrezept von Michael in den Ordner Michael oder Kochrezepte? Oder doch in den Ordner Kochabendplanung, weil Michael gleichzeitig zum Rezept auch einen Termin für das Nachkochen vorschlägt? Egal wie ausgefeilt die Ordnerstruktur auch ist, sie scheitert grundsätzlich an diesen falschen Annahmen.

Moderne E-Mail-Programme wie Apples Mail oder Mozillas Thunderbird erstellen über alle E-Mails einen Volltextindex. Das heißt, eine E-Mail lässt sich nach allen Wörtern und sogar Eigenschaften wie Sender, Empfänger, mit oder ohne Anhang, Datum etc. suchen. Ich kann damit meine E-Mails nach allen Kategorien und nach allen Themen durchsuchen. Aus diesem Grund gibt es in meinem E-Mail-Programm nur einen einzigen Order: Das Archiv. In diesen Ordner kommen alle E-Mails, die bearbeitet worden sind.

Natürlich gestaltet sich die Suche nach E-Mails nicht einfach. Ist der Suchbegriff zu allgemein, findet man zu viele E-Mails. Ist er zu speziell, findet man nicht alle relevanten E-Mails. Dennoch ist die Suchzeit sehr viel geringer als die Zeit, die für das Einzusortieren und Wiederauffinden anfällt. Bestes Beispiel für dieses Verfahren ist Google-Mail, das von Anfang an ohne Ordner entwickelt worden ist.

Probiert es doch mal aus. Aber keine Schummeleien: Damit dieses Verfahren funktioniert, muss man den gedanklichen Schritt machen und die Ordner aufgeben; sonst klickt man sich doch wieder nur durch seine Ordnerstruktur.

Übrigens kommen auch alle meine gesendeten E-Mails ins Archiv. Mit Hilfe der Ansichtsoption “Nach Themen gruppieren” werden von mir geschriebene E-Mails passend mit den empfangen E-Mails angezeigt, so dass es leicht möglich ist, einen Gesprächsverlauf zu rekonstruieren.

Und Du? Wie organisierst Du Deine E-Mails? Welche Software hilft Dir? Lass die anderen Leser teilhaben und schreib einen Kommentar!

★ Ninite, oder Software für die Massen

Mon, 09 Nov 2009 17:59:00 GMT

Vor einiger Zeit berichtete ich über das Problem von Kollegen verstellter Bürostühle und der Qual die über lange Zeit entwickelte Sitzposition wiederzufinden. Eine ähnliche Qual ist das immer gleiche Konfigurieren von Programmen, die man auf mehreren Rechner benutzt. Im Artikel “Programmregal, oder Einstellungen für unterwegs” zeigte ich, wie man Dropbox nutzen kann, um sich diese unnötige Arbeit zu sparen.

Die unnötige Arbeit beginnt aber schon früher, vor der Konfiguration, nämlich bei der Installation der Lieblingsprogramme. Es ist immer wieder der gleiche, dröge Ablauf: Aktuelle Version im Internet suchen, herunter laden, entpacken, installieren und gegebenenfalls den Rechner neustarten; und das für jedes einzelne Programm. In diesem Artikel möchte ich vorstellen, wie man dieses lästige Verfahren auf wenige Mausklicks reduzieren und sich entspannt zurücklehnen kann, während die gewünschten Programm installiert werden.

Windows
Ich erspare mir das einzelne Herunterladen und Installieren von Standardsoftware wie Firefox, Evernote, Dropbox, VLC und anderen unter Windows, indem ich Ninite nutze. Ninite ist ein sehr übersichtlicher und leicht zu bedienender Web-Dienst, bei dem man im ersten Schritt aus einer Liste von populären Programmen seine Lieblingsprogramme auswählt und im zweiten Schritt einen individuellen Installer erzeugen lässt. Dieser Installer wird im dritten Schritt auf den eigenen Rechner geladen. Sobald er ausgeführt wird, lädt er die aktuellen Versionen der ausgewählten Programme herunter und installiert sie mit sinnvollen Einstellungen: Programme werden nach C:\Programme installiert, es werden keine Zusatzpakete wie Toolbars etc. eingespielt und Datenverzeichnisse werden unter Eigene Dateien erzeugt. Dies geschieht komplett ohne eigenes Zutun, so dass nach nur wenigen Minuten alle Programme installiert sind.

Linux
Ein ähnlicher Web-Dienst, der mehr Programme und zusätzlich zu Windows auch Linux unterstützt, ist Allmyapps. Obwohl es mehr Programme zur Auswahl gibt, die man nach Betriebssystemversion unterscheiden kann, ist die Funktionsweise ähnlich zu Ninite.

Für Mac OS X habe ich bisher leider keinen vergleichbaren Dienst gefunden; vielleicht weiß einer von Euch hier Rat. Aber für Windows und Linux erleichtern mir die erwähnten Masseninstaller das lästige Zusammensuchen und Installieren der immer wieder gleichen Anwendungen und ersparen mir dadurch viel Zeit und Nerven.

Preis: kostenlos

Link: http://ninite.com, http://allmyapps.com

Verwandte Artikel:

Programmregal, oder Einstellungen für unterwegs

★ Fokus, oder immer dran bleiben

Tue, 03 Nov 2009 18:21:00 GMT

In der Simpons Folge “Telefonieren nach hause” [deutsch, englisch] arbeitet Homer Simpson als Profikiller und führt zur Tarnung ein Doppelleben als Atomingenieur. Man hätte diese Kaltblütigkeit von Homer nicht erwartet, jedoch erklärt sein geheimes alter ego den Lebensstil der angeblich finanzschwachen Familie Simpson.

Es bleibt unklar, wie Homer seine Zeit und Ressourcen effektiv plant, so dass er sowohl die Arbeit im Kraftwerk, seine Familie als auch seine “Jobs” erledigen kann — und immer genügend Zeit für ein kaltes Bier bleibt. Homer ist einfach ein begnadeter Mensch. Für uns anderen möchte ich im dritten Artikel der Serie Arbeitsplanung vorstellen, wie ich meine Aufgaben jeden Tag effektiv angehe und mit unerwarteten Ereignissen umgehe.

Die ersten beiden Artikel der Serie haben die Werkzeuge für meine Planungen, Remember the Milk (RTM) sowie einen Terminkalender, und die Grundzüge meines Planungssystems vorgestellt. Wie jedoch geht man täglich an seine Aufgaben heran?

Mein Tag

08:00 Uhr
Mein Tag beginnt mit einer Tasse Tee und meinem Terminkalender. Als erstes gehe ich die Termine des Tages durch. Dazu gehören auch die Termine des KalendersZeit, den ich nutze, um Zeit für meine Aufgaben einzuplanen. Als zweites gehe ich durch meine Tagesliste bei Remember the Milk, um zu sehen, welche weiteren Aufgaben ich an diesem Tag bearbeiten muss.

09:00-12:00 Uhr
Die Planung meiner Tagesaufgaben erledige ich am Abend des Vortags. Auf diese Weise kann ich gleich morgens mit der Arbeit beginnen, wenn ich am produktivsten bin. Bei der Planung ist es wichtig darauf zu achten, dass die Aufgaben lösbar sind. Dazu müssen sie konkret formuliert sein. Vage Aufgaben führen dazu, dass man nicht genau weiß, wo man beginnen soll und wann man fertig ist.

Da meine Produktivität vormittags am höchsten ist, vermeide ich jede Art der Unterbrechung oder Ablenkung. Mein Instant-Messaging-Programm, mein E-Mail-Programm, sogar mein Telefon werden abgeschaltet, um diese Zeit des Tages so effektiv wie möglich zu nutzen. Es braucht Übung, der Sucht nach E-Mails zu entkommen, aber es lohnt sich.

Es gibt Tage, an denen gelingt mir konzentriertes Arbeiten nicht. Entweder ich bin müde, abgelenkt oder habe schlicht keine Lust auf meine Hauptaufgabe. An diesen Tagen gehe ich meine RTM Liste @next durch, die über das Tag @next aus allen Projekten den individuell nächste Schritt enthält. Hier kann ich mir leicht eine Aufgabe aussuchen, die auch erledigt werden muss, aber die nicht für heute geplant gewesen ist.

13:00-14:00 Uhr
Nach dem Mittagessen lese ich meine E-Mails, denn meist führen sie zu Handlungsbedarf, der meine Arbeit unterbrechen und meine Konzentration stören würde. Auf diese Weise blende ich Überraschungen und Unvorhersehbares bis zum Nachmittag aus. Es ist wichtig, sich klarzumachen, dass jeder Tag unvorhersehbare Ereignisse bringt und unsere Pläne durcheinander bringt. Indem ich nur den Vormittag verplane und in dieser Zeit äußere Störung auszublenden versuche, bleibt mir nachmittags Zeit zu reagieren und trotzdem die wichtigste Aufgabe zu lösen.

14:00-16:00 Uhr
Gegen 14:00 überfällt mich meist die Mittagsmüdigkeit und schränkt meine Leistungsfähigkeit für ein paar Stunden ein. Diese Zeit nutze ich, um die weniger wichtigen Aufgaben des Tages anzupacken: Anrufe, E-Mails, Post etc. Gibt es nichts zu tun, hilft die @next Liste, um diese Zeit sinnvoll zu nutzen.

16:00-19:00 Uhr
Am Abend werde ich wieder aktiver und meine Leistungsfähigkeit steigt. In diesen Stunden arbeite ich Liegengebliebenes auf, gehe die Notizen des Tages durch und plane den nächsten Tag.

Motivation

Natürlich laufen die wenigsten Tage so reibungslos ab, wie von mir beschrieben. Es gibt Projektphasen, in denen ich den ganzen Tag an nur einer Aufgabe arbeite und alles andere liegen bleibt. Andere Hindernisse sind Krankheiten oder schlichtweg Antriebslosigkeit. Wichtig ist es, sich klar zu machen, dass diese Hindernisse einfach zu unserem Leben dazugehören.

Mir hilft es in dieser Zeit bewusst nicht zu arbeiten. Anstatt im Büro müde und lustlos rumzusitzen, gehe ich nach hause lesen, treibe Sport, oder setze mich vor den Fernseher. Wenn der Kopf nach Entspannung verlangt, sollte man sie ihm geben. Am Abend sollte man jedoch wieder seine Gedanken ordnen und den nächsten Tag konsequent vorbereiten. Nach einer längeren Krankheit oder Urlaub stauen sich natürlich beträchtliche Berge an geplanten Aufgaben und Terminen auf. Hier hilft nur konsequent auszusortieren was unwichtig ist und mit der Planung von vorne zu beginnen.

Es ist nicht einfach, jeden Tag auf die beschriebene Weise zu gestalten. Aber es sicherlich angenehmer als vom Chef den Kopf gewaschen zu bekommen, weil man wieder einmal einen Termin verschlampt oder eine Frist nicht eingehalten hat.

Und Du? Wie strukturierst Du Deinen Tag und auf welche Weise gehst Du mit unvorhergesehenen Ereignissen um? Welche Software hilft Dir? Lass die anderen Leser teilhaben und schreib einen Kommentar!

Verwandte Artikel:

★ Instapaper, oder die persönliche Überallzeitung

Wed, 28 Oct 2009 10:41:00 GMT

Im Jahr 1676 warnte der Hofkanzler Ashaver Fritsch vor Zeitungen. Die unzeitige und arbeitsstörende Begierde nach dem Zeitungslesen würde süchtig machen. Es ist interessant, dass dieser Gelehrte bereits vor 333 Jahren ein Phänomen beschrieb, dem ich mich tagtäglich ausgesetzt fühle. Es gibt zu viele spannende Nachrichten, zu viel neues Wissen, von dem man sich all zu leicht ablenken lässt.

Ein anderes Phänomen ist die Vergänglichkeit der heutigen Neuigkeiten. Oft stoße ich beim Stöbern im Internet auf interessante Artikel und Seiten. Lese ich sie jedoch nicht sofort oder speichere sie ab, finde ich sie selten wieder, da sie in Zwischenzeit durch neuen Inhalt ersetzt worden sind. Um meinen Arbeitsprozess nicht zu unterbrechen, lasse ich sie deshalb in einem Browser-Fenster mit der Absicht sie später zu lesen offen. Wenn ich dann in der Bahn oder im Wartezimmer Zeit zum Lesen habe, helfen mir die offenen Browser-Fenster im Büro jedoch wenig.

Aus diesem Grund setze ich den Web-Dienst Instapaper ein, der mir dabei hilft, während Wartezeiten doch noch die spannenden Artikel zu lesen, die ich mir ansehen wollte.

Instapaper besticht durch seine Einfachheit. Damit Instapaper Web-Seiten speichern kann, muss man sich zunächst anmelden. Dafür genügt schon allein eine E-Mail-Adresse und ein Passwort ist nicht nötig. Sollte man sich aber vor fremden Augen schützen wollen, so kann man seine Lesezeichen mit einem Passwort schützen.

Um Artikel und andere Web-Seiten für das spätere Lesen zu speichern, fügt man in der Lesezeichenleiste des Browsers ein Bookmarklet ein. Findet man eine spannende Seite, so klickt man nur auf dieses spezielle Lesezeichen und die aktuell angezeigte Web-Seite wird gespeichert. Nun kann man von überall aus Instapaper im Browser aufrufen und findet dort seine gespeicherten Lesezeichen.

Instapaper bietet dabei die Möglichkeit die gespeicherten Seiten direkt anzuspringen oder eine von Bildern und Werbung befreite, reine Textansicht zu erzeugen. Dies erleichtert das Lesen und reduziert die zu übertragenden Datenmengen. Dies ist besonders für mobile Geräte nützlich, für die Instapaper eine speziell angepasste Version anbietet.

Für unterwegs gibt es zusätzlich eine kostenlose, aber mit Werbeeinblendungen versehene iPhone-Anwendung, die bis zu 10 Artikeln offline speichert, so dass man die Seiten auch dann lesen kann, wenn gerade keine Internet-Verbindung zur Verfügung steht. Eine werbefreie Version mit Zusatzfunktionalität gibt es für US$ 5.

Mit Instapaper kann ich von allen Rechnern aus und auch unterwegs über mobile Geräte auf meine gespeicherten Artikel zugreifen ohne sie umständlich wieder hervorsuchen zu müssen. Auf diese Weise habe ich meine persönliche Zeitung immer und überall dabei. Doch Vorsicht: Wie Browser-Fenster können auch Instapaper-Lesezeichen sehr schnell unübersichtlich werden. Da hilft nur noch Löschen und von vorn beginnen.

Preis: kostenlos, iPhone-Anwendung kostenlos / erweiterte iPhone-Anwendung US$ 5.

Link: http://www.instapaper.com

Und Du? Wie gehst Du mit den vielen spannenden Artikeln um? Welche Software hilft Dir? Lass die anderen Leser teilhaben und schreib einen Kommentar!

Verwandte Artikel:

★ Arbeitsplanung, oder das Was und Wann

Mon, 19 Oct 2009 17:16:00 GMT

Homer Simpson ist ein viel beschäftigter Mann. Obwohl er allgemein als unterbelichtet gilt, war Homer bereits Sicherheitsfachmann in einem Atomkraftwerk, NASA Astronaut, Bodyguard, Fahrzeugentwickler, Profikiller, Internet-Service-Provider, Mafiaboss und Polizeichef [(engl.)]. Man kann sich vorstellen, dass es eine schwierige Herausforderung ist, diese vielen Tätigkeiten unter einen Hut zu bringen ohne etwas zu vergessen.

Wie Homer Simpson dies bewältigt ist sein Geheimnis. Jedoch auch unsere tägliche Arbeit ist meist so umfangreich, dass ohne Koordination Aufgaben verloren gehen. In diesem Artikel als Teil der Serie Arbeitsplanung beschreibe ich, wie ich sowohl meine Projekte und Aufgaben, als auch meine Zeit plane, ohne dass Aufgaben vergessen werden. Im ersten Teil dieser Serie “RTM, oder denk an die Milch” habe ich gezeigt, wie man seine Aufgaben ortsunabhängig und jederzeit zugreifbar verwaltet.

Grundsätzlich gibt es bei der Arbeitsplanung zwei Dinge zu verwalten: 1. Die Arbeit, welche man erledigen möchte und 2. die Zeit, die man dafür braucht.

Die Arbeit

Es geht sicherlich vielen Lesern so wie mir, ich arbeite selten an nur einem Projekt, sondern habe immer mehrere Baustellen. Um keine Aufgabe zu vergessen, ist die erste Regel der Arbeitsplanung das Aufschreiben. Aufgaben müssen festgehalten werden, denn sonst fallen sie, wie ein Stapel Papier vom übervollen Schreibtisch, aus unserem Gehirn heraus. Um die Übersicht über meine Aufgaben zu behalten, ist die zweite Regel der Arbeitsplanung das strukturierte Ablegen der festgehaltenen Aufgaben. Dazu nutze ich ein dreigliedriges System. Eine Aufgabe ist immer Teil eines Projektes, welches immer Teil eines Ziels ist.

Ziele sind allgemeine Verantwortungsbereiche, zum Beispiel die Pflege meines Blogs. Dazu gehört es, neue Artikel zu schreiben und die Blog-Seiten zu pflegen. Das Veröffentlichen eines Artikels besteht aus mehreren Teilaufgaben, die ich eine nach der anderen abarbeite.

Natürlich kann man bei größeren Projekten nicht alle Teilaufgaben von Anfang an konkret benennen, da sich das Projekt entwickelt und man viele Probleme und Aufgaben noch gar nicht kennt. Man sollte ruhig alle Aufgaben, wie vage sie auch sind, festhalten und ablegen. Sie werden sich mit Fortschreiten der Projektzeit konkretisieren. Wichtig ist es aber, dass man die nächste Aufgabe, den nächsten Schritt konkret benennen kann. Nur eine konkrete, lösbare Aufgabe kann auch abgearbeitet werden. Deswegen ist Regel drei das Sicherstellen einer lösbaren, konkreten Aufgabe, die man als nächsten Schritt eines Projektes abarbeiten wird.

Für die Verwaltung meiner Aufgaben nutze ich Remember the Milk. Remember the Milk zwingt keine Organisationsmethoden auf, sondern passt sich meiner persönlichen Art so wie ich es brauche an. RTM kennt nur Aufgaben, die man mit Tags leicht strukturieren kann. Ziele lege ich durch eine Aufgabe an, die als erstes Zeichen ein '+’ hat. Zum Beispiel +eigadget. Die Projekte eines Ziels tragen als erstes Zeichen ein ‘.’ im Namen: Zum Beispiel .ei_artikel. Dieses Projekt-Tag wird an alle Teilschritte des Projekts vergeben. Die als nächste zu lösende Aufgabe wird mit dem Tag @next markiert. Dadurch kann man sich die nächsten Schritte aller Projekte leicht aufzeigen lassen.

Sind alle Aufgaben erledigt, lösche ich die verbleibende Projektaufgabe und schließe das Projekt damit ab.

Die Zeit

Neben der Verwaltung der Aufgaben muss man ebenfalls planen, wann die Aufgaben erledigt werden sollen. Kleinigkeiten, wie das Vereinbaren eines Arzttermins, kann man zwischendurch machen, aber komplizierte Aufgaben wie das Schreiben eines Artikels benötigen dedizierte Zeit und Konzentration.

Einmal pro Woche, meist ist dies sonntags, gehe ich meine Projekte durch und überlege, welche der nächsten Teilschritte ich in der kommenden Woche anpacken will. Fällt es mir dabei schwer, abzuschätzen wie lange ich für die Erledigung einer konkreten Aufgabe brauchen werde, verlasse ich mich auf meine Intuition. Wenn die Aufgabe innerhalb der geplanten Zeit nicht schaffe, sortiere ich sie wieder in mein System ein.

Für die konkrete Zeitplanung nutze ich einen digitalen Kalender wie Google Calender oder iCal für Mac OS X. Sie bieten den Vorteil, dass man mehrere, unabhängige Kalender definieren kann, um private von geschäftlichen Terminen zu trennen. Für die Zeitplanung setze ich einen Kalender namens Zeit ein, mit dem ich mir für jeden Tag Termine einplane, während derer ich meine Wochenaufgaben bearbeite. Für Kleinigkeiten, wie die Absprache eines Arzttermins, plane ich während des Mittagstiefs eine Stunde für Kleinigkeiten ein.

Die Arbeitsplanung

Dieser Artikel gibt eine Übersicht, wie ich versuche Homer Simpsons Emsigkeit nachzueifern. Ich nutze diese Methode auch für mein Privatleben. Natürlich ist sie meine ganz persönliche Methode und jeder sollte sich genügend Freiheit nehmen, seine eigene Methode zu entwickeln. Wenn Ihr Fragen, Anregungen oder eigene Methoden habt, dann schreibt mir oder stellt einen Kommentar ein, so dass wir unsere Methoden gemeinsam verfeinern können.

Im nächsten Artikel dieser Serie werde ich beschreiben, wie man die einzelnen Aufgaben tatsächlich umsetzt bzw. erledigt, seine Motivation dabei aufrecht erhält und was man manchen kann, wenn einem die Arbeit trotz Planung über den Kopf wächst.

Verwandte Artikel:

★ TeamViewer, oder das digitale Fernrohr

Wed, 14 Oct 2009 18:03:00 GMT

Das erste Fernrohr wurde vom holländischen Brillenmacher Hans Lipperhey erfunden. Plötzlich sah man sehr weit entfernte Objekte so groß, als stünde man direkt vor ihnen und könne sie anfassen. Galileo Galilei entwickelte das Fernrohr weiter und konnte sogar Planeten und deren Mode in unserem Sonnensystem beobachten.

Helfe ich Freunden am Telefon oder per E-Mail bei Problemen mit ihren Computern, so wünsche ich mir manchmal auch ein digitales Fernrohr, um direkt zu sehen und eingreifen zu können. Mit TeamViewer ist dies tatsächlich trotz dynamischer Internetverbindung und Firewall möglich.

Die gängigen Betriebsysteme bieten heute bereits Anwendungen zur Fernwartung: Windows bringt die Remotedesktopverbindung, Mac OS X Screen-Sharing und für Linux hat sich VNC eingebürgert. Diesen Lösung ist jedoch gemein, dass für den Fernwartungszugriff eine direkte Netzwerkverbindung notwendig ist. Wählt man sich per DSL mit dynamischen IP-Adressen ins Internet ein und nutzt dafür einen Router mit Network-Address-Translation, ist der Zugriff mit erheblichem Konfigurationsaufwand auf beiden Seiten verbunden. TeamViewer geht hier einen anderen Weg und vermittelt die Verbindung über zentrale Server, so dass transparent ohne Komplikationen eine Verbindung zwischen beiden Rechnern aufgebaut werden kann.

Installation
Die Installation von TeamViewer ist kinderleicht und kann sehr leicht blind per Telefon abgesprochen werden. Man lädt die kostenlose Software direkt von der Startseite herunter und installiert sie per Doppelklick.

Verbindungsaufbau
Der Verbindungsaufbau gestaltet sich ebenfalls sehr einfach. Nachdem beide Seiten TeamViewer gestartet haben, übermittelt der Hilfesuchende eine eindeutige Rechner-ID und das für jede Verbindung neuerstellte Passwort. Mit diesen Daten kann der Helfer die Verbindung aufbauen. Dieses Verfahren stellt sicher, dass der Helfer nur dann Zugriff auf den entfernten Rechner bekommt, wenn dies explizit gewünscht ist. Sobald TeamViewer beendet wird, endet auch die Fernwartungsverbindung.

http://ueberallbuero.de/wp-content/uploads/2009/10/TeamViewer_RemoteAccess.png

Geisterhand
Während der Fernwartungssitzung kann der Helfer die Tastatur und Maus fernsteuern. Dabei hat der Hilfesuchende stets die Möglichkeit einzugreifen. Ein durchsichtig schimmerndes Fenster informiert auf dem entfernten Rechner über den aktiven Fernzugriff. Wenn nötig, können sogar Dateien zwischen beiden Rechnern ausgetauscht werden bzw. über eine Chat-Verbindung Textnachrichten ausgetauscht werden.

Professionell
TeamViewer kann auch genutzt werden, um Präsentationen auf dem entfernten Rechner anzuzeigen oder Dateien zu übertragen. Noch mehr Funktionen als die für private Zwecke kostenlose Version bieten die kommerziellen Erweiterungen, mit denen man ganze Netzwerke bequem von einem Arbeitsplatz aus verwalten kann.

http://ueberallbuero.de/wp-content/uploads/2009/10/TeamViewer_FileTransfer.png

TeamViewer sticht durch seine hervorragende Bildqualität auch bei geringen Bandbreiten hervor und erleichtert in vielen Fällen die Diagnose und Korrektur von Problemen auf entfernten Rechnern. Zusätzlich eignet es sich bei Telefonkonferenzen für Fernpräsentationen oder zum gezielten Austausch von Dateien. Für mich ist TeamViewer in kurzer Zeit zu einem unverzichtbaren Werkzeug geworden. Probiert es aus und berichtet von Euren Erfahrungen.

Preis: Für den privaten Einsatz kostenlos

Link: http://teamviewer.com/

Und Du? Welche Software hilft Dir bei der Fernwartung oder der Lösung von Computerproblemen auf entfernten Geräten ? Lass die anderen Leser teilhaben und schreib einen Kommentar!

Verwandte Artikel:

Netalyzr, oder “Das Internet geht nicht”

★ Doodle, oder Abstimmen leicht gemacht

Tue, 22 Sep 2009 17:49:00 GMT

Am 27.09.2009 wird die Wahl zum 17. Deutschen Bundestages stattfinden, die bestimmt welche Parteien und Personen in der kommenden Legislaturperiode Deutschland politisch lenken und kontrollieren werden und damit, wie das Zusammenleben in Deutschland organisiert wird. Die Organisation von Menschen ist aber nicht nur auf bundespolitischer Ebene eine große Herausforderung, sondern auch im eigenen Privat- und Berufsleben manchmal sehr kompliziert. Jeder, der mit mehreren Freunden ins Kino gehen oder ein Treffen planen möchte, steht vor der Aufgabe, einen gemeinsamen Termin zu finden, der allen passt. Dazu versucht man unter anderem mit langen, ausufernden E-Mail-Korrespondenzen eine Lösung zu finden.

Wie man dies mit Doodle viel einfacher, eleganter und zuverlässiger machen kann, stelle ich in diesem Artikel vor.

Doodle ist eine Web-Anwendung, die sich ganz der Koordinierung von gemeinsamen Terminen und Abstimmungen widmet. Dabei legt Doodle besonderen Wert auf leichte Bedienbarkeit und verzichtet konsequent auf komplizierte Anmeldeverfahren, Registrierungen und Passwörter.

Das Anlegen einer Terminumfrage besteht aus drei Schritten. Im ersten Schritt gibt man der Umfrage einen Namen und wenn man möchte eine Beschreibung. Außerdem kann man eine E-Mail-Adresse angeben, um über Abstimmungsergebnisse informiert zu werden. Dies ist aber nicht erforderlich. Im zweiten und dritten Schritt legt man die möglichen Tage und Uhrzeiten für das Treffen fest.

Nach dem dritten Schritt erhält man von Doodle einen Administrations-Link und einen Teilnehmer-Link. Den Administrations-Link nutzt man, um Änderungen an der Umfrage zu machen oder sie später zu löschen. Vergisst man eine abgelaufene Umfrage zu löschen, wird dies von Doodle frühestens 30 Tage nach dem letzten Zugriff automatisch übernommen.

Den Teilnehmer-Link verschickt man an seine Freunde, so dass sie an der Umfrage teilnehmen und abstimmen können. Die eingeladenen Freunde müssen nur auf den Link klicken, ihren Namen eintragen und ihre Wahl treffen, die sie auch jederzeit ändern können. Grundsätzlich ist die Teilnahme an einer Doodle-Umfrage nur mit diesem Link möglich, der für jede Umfrage unterschiedlich ist. Dadurch können nur eingeladene Personen teilnehmen. Durch den konsequenten Verzicht auf Benutzeranmeldungen, kann eine Abstimmung vollständig anonym erfolgen. Jedoch ist auch Missbrauch möglich, denn jeder Eingeladene kann die Wahl eines Anderen verändern. Aber schließlich handelt es sich um die Wahl des nächsten Treffens und nicht um die Wahl zum Deutschen Bundestag.

Doodle-Umfragen sind sehr leicht zu erstellen und von allen Beteiligten leicht zu nutzen. Es vereinfacht in vielen Bereichen die gemeinsame Koordination und eignet sich sowohl für private als auch berufliche Planungen. Über Terminabsprachen hinaus lässt sich Doodle für Abstimmung über beliebige Dinge nutzen. Für Unterwegs bietet es außerdem die spezielle Web-Seite m.doodle.com für Mobilegeräte.

Preis: kostenlos

Link: http://www.doodle.com/main.html

Und Du? Wie organisierst Du Deine Freunde? Welche Kniffe helfen Dir? Lass die anderen Leser teilhaben und schreib einen Kommentar!

★ Ideenkiste, oder Sammeln mit dem Überallelefanten

Tue, 15 Sep 2009 18:17:00 GMT

Kreative Arbeit braucht Zeit. Sie lässt sich selten erzwingen oder kontrollieren. Ideen kommen nicht wenn man es will, sondern wenn sie wollen, spontan, wenn man nicht mit ihnen rechnet. Dies wusste schon das Universalgenie Leonardo da Vinci und führte deswegen seine berühmten Notizbücher (engl.), in denen er alle seine Einfälle festhielt.

Die berühmte Choreographin Twyla Tharp (engl.) nutzt zum Ideensammeln eine einfache Plastikkiste. Im Vorfeld der Entwicklung einer neuen Choreographie wirft sie alles Inspirierende in diese Kiste: Postkarten, Bücher, Zeitungsartikel und sogar Möbelstücke. Ist die Kiste gefüllt, leert sie sie aus, geht die Fundstücke durch und lässt sie zu sich sprechen. Daraus entwickelt Twyla Tharp die Elemente ihrer Choreographien*****.

Wie ich das Konzept der Ideenkiste für meine tägliche Arbeit nutze und wie es mir hilft Vorträge, wissenschaftliche Texte, Computer-Programme oder Flugmaschinen zu entwickeln, zeige ich in diesem Artikel.

Das Projekt

Meine Blog-Artikel entstehen entweder spontan, wenn ich ein konkretes Problem lösen musste, oder gezielt, über eine längere Zeit geplant. Ich suche mir ein Thema aus und beginne meine Ideen dazu aufzuschreiben. Hier hat sich Evernote sehr bewährt, das ich für viele Aufgaben nutze. Ich beginne meist mit einer Textnotiz, in der ich meine erste Idee aufschreibe und festlege, was das Ziel des Artikels sein soll. Über die nächsten Tage sammele ich dann Bilder, Zitate und Links, die zu dem Thema passen.

Das Sammeln

Bilder füge ich per Drag’n’Drop direkt in Evernote ein, Zitate bekommen ihre eigene Notiz und Links bzw. Webseiten kommen über die praktische Clipper-Funktion direkt aus dem Browser vollautomatisch zu Evernote. Die so entstehenden Notizen bekommen alle dasselbe Tag, um sie gezielt wieder finden zu können. Wenn es zu viele werden, füge ich sie über die Funktion zum Zusammenführen von Notizen zusammen. So entsteht mit der Zeit eine einzelne Evernote-Notiz mit allen Fundsachen und Ideen zum nächsten Artikel.

Die Umsetzung

Bevor ich mit dem tatsächlichen Schreiben beginne, gehe ich diese Notiz durch und erstelle, wieder in Evernote, daraus die Skizze des neuen Artikels. Natürlich verwerfe ich viele der gesammelten Informationen wieder, recherchiere Dinge erneut. Aber das wichtigste ist, dass meine Gedanken nicht verloren gehen. Genauso gehe ich auch beim Programmieren und Vorbereiten von Vorträgen vor. Ich definiere die Aufgabe, die mein Programm lösen soll bzw. das Ziel meines Vortrags, und sammele API-Dokumentationen, Programm-Code-Schnippsel, Links zu How-Tos, Bilder, Zitate usw. in meiner Ideenbox, bis ich genügend Fundstücke habe, um mir konkret Gedanken zu machen und mit der eigentlichen Umsetzung zu beginnen.

Das Resümee

Wenn man vor einer Aufgabe steht, die kreatives Denken voraussetzt, so ist es sinnvoll zunächst Ideen zusammenzutragen. Es ist viel leichter, Gedanken reifen zu lassen und sie immer mal wieder aufzuschreiben, als Ideen zu erzwingen. Dafür ist Geduld notwendig. Wann immer ich bewusst oder unbewusst über Inspirierendes stolpere, füge ich es der passenden Ideenbox in Evernote hinzu. So entstehen für Vorträge Storys, um die Zuhörer von meinem Thema zu überzeugen, Software-Entwürfe für komplexe Computerprogramme und Blog-Artikel, wie dieser.

Der Appell

Versucht es selbst: Seid geduldig, lasst die Ideen zu Euch kommen und verstaut sie sorgfältig in Eurer Ideenbox.

Preis: Evernote: kostenlos, Premiumversion $45 pro Jahr

Link: http://www.evernote.com

Und Du? Wie sammelst Du Ideen für Deine Projekte? Welche Software hilft Dir? Lass die anderen Leser teilhaben und schreib einen Kommentar!

Verwandte Artikel:

★ Netalyzr, oder Das Internet geht nicht

Mon, 07 Sep 2009 19:06:00 GMT

“Ich kann nicht drucken!” und “Das Internet geht nicht!” sind vermutlich die von Administratoren und Nerds meist gehassten Sätze. Kunden und Freunde bauschen kleine IT-Probleme gern zu gigantischen Katastrophen, wie dem Totalausfall des auf Ausfallsicherheit angelegten Internets, auf. Schon die erste Nachfrage führt häufig zu Antworten, wie “Nein, E-Mail geht, aber die Seite www.example.com wird nicht richtig angezeigt”.

Leider wird diese Auskunft meist erst dann gegeben, wenn man 30 Minuten unterwegs war und persönlich vor dem Kunden oder Bekannten steht. Bevor man losfährt, sollte man es also mit einer Ferndiagnose probieren: Für den Fall des kaputten Internet bietet die Universität Berkeley das sehr aufschlussreiche Prüfprogramm Netalyzr, “Debug your Internet”*, an, das Abhilfe schaffen kann und ich in diesem Artikel beschreibe.

Netalyzer ist ein Java-Applet und wird im Browser ausgeführt. Es nutzt zur Analyse sowohl die Server in Berkeley als auch lokal gesammelte Informationen. Dadurch kann es die Internetverbindung von beiden Seiten untersuchen und die Ergebnisse miteinander verknüpfen. Dies erlaubt eine sehr detaillierte und präzise Untersuchung. Die Ergebnisse werden in Kategorien übersichtlich dargestellt und leicht verständlich erklärt. Eine Einstufung nach dem Ampelprinzip (grün, gelb, rot) signalisiert die Schwere eines gefundenen Problems.

http://ueberallbuero.de/wp-content/uploads/2009/09/netalyzer_start.png

Untersuchung

Die Untersuchung kann mehrere Minuten dauern während derer sich Netalyzer alle relevanten Aspekte einer Internetverbindung vorknöpft. Es wird die IP-Adresse untersucht, auf NAT geprüft, eventuelle vorhandene Proxys oder Netzwerkfilter gesucht und die Browserversion abgefragt. Zusätzlich wird die EICAR Testdatei geladen. Diese harmlose Datei wird zur Überprüfung der korrekten Arbeitsweise von Antivirus-Software eingesetzt und sollte zu einer Warnmeldung führen. Bleibt diese aus, muss man seine Konfiguration überprüfen.

Auswertung

Aus den gesammelten Daten, die man auch in Rohform einsehen kann, (Link Transcript) lassen sich blockierte Ports, Netzwerkeigenschaften (Bandbreite, Verzögerung etc.) sowie Web- und DNS-Filterung ablesen. Zusätzlich wird die Analyse — ohne personenbezogene Daten — gespeichert und ist damit jederzeit über einen Permalink abrufbar, so dass man sie per Telefon oder E-Mail weitergeben kann.

http://ueberallbuero.de/wp-content/uploads/2009/09/netalyzer_results.png

Ergebnis

Mit Hilfe dieser Auswertung lassen sich viele Probleme schnell feststellen. Zum Beispiel erlaubt meine Firewall keine ausgehenden Verbindung auf Port 135, so dass ich nicht auf Windows-Freigaben im Internet zugreifen kann. Gleiches gilt grundsätzlich für UDP-Pakete außer für DNS, so dass einige Peer-to-Peer-Programme nicht richtig funktionieren (s. Abbildung oben).

Schlussfolgerung

Netalyzr ist ein praktisches Werkzeug, das die Ferndiagnose von Internetzugängen erleichtert und damit für gesunden Blutdruck bei Nerds und Systemadministratoren sorgt. Insbesondere die Aufdeckung von Firewalls, Proxys und Filtern hilft, die eigene Privatsphäre zu schützen und unbekannte Proxys und Filter aufzudecken.

Preis: kostenlos

Link: http://netalyzr.icsi.berkeley.edu/; IP-Adresse 192.150.187.31, falls DNS nicht mehr funktioniert

Und Du? Wie entkommst Du der Reise zu den Orten der totalen Internetverwüstung? Welche Software hilft Dir? Lass die anderen Leser teilhaben und schreib einen Kommentar!

*Der Euphemismus “Dein Internet” sei den Entwicklern verziehen. Vermutlich haben ähnlich Erfahrungen sie zu Netalyzr inspiriert.

★ Quecksilber und Schneeleoparden

Tue, 01 Sep 2009 17:43:00 GMT

Apple hat am Freitag, 28.08.2009, die 6. Version von Mac OS X veröffentlicht: Mac OS X 10.6 “Snow Leopard”. Als Nerd habe ich diese neue Version natürlich direkt ausprobiert und bin auf folgendes Problem gestoßen: Quicksilver stürzt ohne Kommentar ab und lässt sich somit nicht nutzen. Zum Glück konnte ich die Ursache finden und beheben. Wie das geht, beschreibe ich kurz in diesem Artikel.

Die Funktionalität von Quicksilver kann mit Plug-ins erweitert werden. Erst durch diese Plug-ins gewinnt Quicksilver die überragende Mächtigkeit, die es so beliebt macht. Nachdem Quicksilver nicht mehr startete, habe ich es im Terminal ausgeführt, um die Fehlerausgaben von Quicksilver anzusehen.

Dabei viel mir auf, dass Quicksilver vermutlich während des Ladens der Plug-ins abstürzt. Da Quicksilver nicht mehr startet, lassen sich Plug-ins nicht deaktivieren. Man muss sie löschen — kann sie aber nachladen, sobald Quicksilver wieder funktioniert.

Zuerst legt man eine Sicherungskopie der Quicksilver-Konfiguration an. Dazu startet man das Programm Terminal und führt folgenden Befehl aus:

cp -R ~/Library/Application\ Support/Quicksilver Quicksilver.leopard

Nun lässt man sich die installierten Plug-ins anzeigen:

ls ~/Library/Application\ Support/Quicksilver/PlugIns

Zum Schluss löscht man die Plug-ins, eins nach dem anderen, bis Quicksilver wieder startet. In meinem Fall war es das “Services Menu Module” Plugin:

rm -R ~/Library/Application\ Support/Quicksilver/PlugIns/Services\ Menu\ Module.qsplugin

Danach lässt sich Quicksilver wieder problemlos starten.

Natürlich kann bei Euch ein anderes Plug-in der Bösewicht sein bzw. die Kombination von mehreren verursacht einen Fehler. Ihr solltet aber auch dann mit der oben beschriebenen Methode Quicksilver schnell wieder funktionsfähig bekommen.

Link: http://www.blacktree.com/

Und Du? Auf welche Probleme mit Snow Leopard bist Du gestoßen? Und konntest Du sie umschiffen? Lass die anderen Leser teilhaben und schreib einen Kommentar.

★ Programmregal, oder Einstellungen für unterwegs

Mon, 24 Aug 2009 17:36:00 GMT

Der Nerd verbringt die meiste Zeit sitzend und über kurz oder lang kommen Verspannungen und Rückenschmerzen. Tatsächlich zählt die Erkrankung der Ledenwirbelsäule als Berufskrankheit (Nr. 2110). Vorbeugen kann man mit Sport und ergonomischen Arbeitsplätzen. Dazu zählt insbesondere die korrekte Sitzposition und damit das Einstellungen von Tisch und Stuhl. Leider schnappen sich manche Kollegen manchmal den über Wochen fein justierten Stuhl und verstellen ihn. Die Qual dies wieder rückgängig zu machen ist sicherlich vielen bekannt.

Eine ähnliche Qual ist es, Anwendungen auf mehreren Rechnern einzustellen. Es ist immer dieselbe, dröge Arbeit die Konfigurationen abzugleichen; beispielsweise kopiert man die Firefox-Lesezeichen oder die Musik aus iTunes immer wieder aufs Neue. Wie man dies mit Hilfe von Dropbox umgehen kann und damit Zeit und Nerven spart, zeigt dieser Artikel.

Ich habe Dropbox im Artikel “Dropbox, oder das Überallregal” vorgestellt. Es synchronisiert automatisch und für den Benutzer völlig transparent Daten zwischen mehreren Rechnern. Dabei werden nur Änderungen übertragen. Zusätzlich lassen sich beliebige Änderungen und sogar gelöschte Dateien wiederherstellen.

Datenverzeichnis austauschen

Dropbox erzeugt für die Synchronisation ein spezielles Verzeichnis; genannt “Dropbox”. Am einfachsten lassen sich Anwendungskonfigurationen auszutauschen, wenn man das Datenverzeichnis in der Anwendung verändern kann. Zum Beispiel geht dies in iTunes und Papers:

Datenverzeichnis verschieben

Es gibt aber auch Anwendungen, die es nicht gestatten, das Datenverzeichnis zu verändern. Hier hilft ein einfacher Kniff weiter: Man verschiebt das Verzeichnis in die Dropbox und setzt einen symbolischen Link an die Stelle, wo die Anwendung ihre Daten erwartet. Auf diese Weise bemerkt die Anwendung gar nicht, dass sich etwas geändert hat. Unter Linux und Mac OS X ist dies mit einfachen Bordmitteln auf der Kommandozeile möglich. Das Bild zeigt, wie man dies für Firefox machen kann.

http://ueberallbuero.de/wp-content/uploads/2009/08/Term_Firefox.png

Symbolische Links unter Windows

Das Windows Dateisystem NTFS unterstützt seit Windows NT symbolische Links (Junctions genannt), jedoch lassen sie sich nicht direkt nutzen. Das kleine Hilfsprogramm Junction von Microsoft erstellt symbolische Links unter Windows. Grafisch lässt sich dies mit der Link Shell Extension für den Explorer machen. Seit Windows Vista gibt es das Bordprogramm mklink, das die gewünschten Links in der Kommandozeile erzeugt.

Datenverzeichnisse

Die Orte der Datenverzeichnisse unterscheiden sich sehr stark zwischen Windows, Mac OS X und Linux und können je nach Programm abweichen. Hier muss man ein bisschen suchen. Für Firefox gilt:

Windows 7: C:\Users\pustina\AppData\Local\Mozilla
XP: C:\Dokumente und Einstellungen\pustina\Anwendungsdaten\Mozilla
Mac OS X: /Users/pustina/Library/Application Support/Firefox
Linux: /home/pustina/.mozilla/

Einmal konfiguriert, funktioniert der Austausch von Programmeinstellungen mittels Dropbox problemlos und wirkt sich sehr beruhigend auf meine Nerven aus. Insbesondere das lästige Abgleichen von Lesezeichen, meiner Paper-Datenbank und meiner Instant-Messaging-Anwendung geschieht nun automatisch ohne mein Zutun.

Preis: 2 GB kostenlos, 50 GB $99 pro Jahr, 100 GB $199 pro jahr

Link: http://www.getdropbox.com/**
**

Und Du? Wie umgehst Du das lästige Nachkonfigurieren Deiner Anwendungen? Oder funktioniert diese Idee für Dich nicht? Lass die anderen Leser teilhaben und schreib einen Kommentar!

Verwandte Artikel:

Dropbox, oder das Überallregal

★ RTM, oder denk an die Milch

Tue, 18 Aug 2009 11:17:00 GMT

“Neinn!”, der legendäre Ausruf von Homer Simpson, wenn wieder mal etwas daneben geht, ist vielen bekannt. Ein sicherlich allen bekannter Auslöser für ein solches “Neinn!”, ist die Milch, an die man hätte denken sollen, aber vergessen hat.

Das Vergessen der Milch steht sprichwörtlich für das Phänomen, zu viele Aufgaben in zu wenig Zeit erledigen zu müssen, so dass Aufgaben irgendwann “hinten” herunterfallen und verloren gehen. Um dies zu verhindern, ist es sinnvoll Aufgaben und Projekte aufzuschreiben.

Wie ich meine Aufgaben mit Web 2.0 ortsunabhängig, jederzeit zugreifbar und stets aktuell verwalte, wird in nächster Zeit eine Serie von Artikeln aufzeigen. Beginnen möchte ich mit der Vorstellung von “Remember the Milk”, das die Basis meines Systems bildet.

Es gibt viele Gründe, weshalb man an einem Tag nicht alle Aufgaben erledigt kann, die man sich vorgenommen hat. Wichtig ist jedoch, dass Aufgaben nicht verloren gehen, sondern zuverlässig irgendwann wieder aufgenommen werden. Im Artikel “Ideen sind überall, oder auf Hemingways Spuren” habe ich beschrieben, Ideen und Gedanken schnell zu Papier zu bringen, damit man nichts vergisst und schnell wieder zu seiner aktuellen Arbeit zurückkehren kann. Papier hat jedoch den Nachteil, physisch an einen Ort gebunden zu sein; beim Einkauf liegt die Einkaufsliste im Büro. Aus diesem Grund überführe ich meine Papiernotizen nach Remember the Milk.

Remember the Milk, oder kurz RTM, ist eine web-basierte Aufgabenverwaltung und ist sehr simpel aufgebaut: Es gibt Aufgaben, Listen und Tags. Das genügt, um einfache Einkaufserinnerung und komplexe Projekte damit zu verwalten. Der Vorteil dieses einfachen Ansatzes ist es, dass RTM kein bestimmtes Organisationssystem erzwingt. Egal ob Getting Things Done, Zen to Done, Doing Things Different oder einfache Listen, RTM eignet sich für alles.

RTM gibt es in einer kostenlosen und einer erweiterten, abonnementbasierten “Pro” Version für US$ 25 im Jahr. Die kostenlose Version ist voll funktionsfähig und absolut ausreichend, um Aufgaben und Projekte zu verwalten. Herausragend ist RTMs Kommunikationsfreudigkeit: Aufgaben können per Instant-Messaging, Twitter, E-Mail und Quicksilver hinzugefügt werden. Alle Aufgaben können per iCal und RSS-Feeds mit desktop-basierten Anwendungen wie Outlook und Mac OS X iCal sowie online mit GMail und Google Calender synchronisiert werden. Die Pro-Version erweitert die Kommunikationsfähigkeit von RTM, um SSL-basierte Übertragungsverschlüsselung, eine iPhone-Anwendung bzw. die Synchronisation mit Windows-Mobile und Blackberry, sowie bevorzugten E-Mail-Support.

Ich verzichte konsequent auf Desktop-Anwendungen und nutze für den täglichen Einsatz ausschließlich die Web-Oberfläche. Dadurch bin ich unabhängig von unterschiedlich zu bedienenden Anwendungen, denn egal auf welchem Rechner, die Web-Oberfläche ist immer gleich. Sehr hilfreich ist die fast vollständige Bedienbarkeit per Tastatur (engl.) und die Unterstützung on Google Gears. Dadurch fühlt sich die Web-Oberfläche wie eine Desktop-Anwendung an und funktioniert auch ohne permanenten Internet-Zugang. Unterwegs und ohne Rechner setze ich die iPhone-Anwendung ein, so dass ich bequem alle Aufgaben einsehen und bearbeiten kann. RTM bietet aber auch eine optimierte Web-Anwendung für mobile Geräte.

Remember the Milk ist die zentrale Schaltstelle meines Tages. Was getan werden soll, was liegen geblieben und was neu dazugekommen ist — RTM weist mir den Weg. Die Plattformunabhängigkeit und der simple und flexible Aufbau sind die großen Vorteile gegenüber der Schar von Selbstorganisations-Software.

Im nächsten Artikel dieser Serie werde ich beschreiben, wie ich meine Arbeitswoche mit Remember the Milk sowie einem Kalender plane und wie neue Aufgaben in mein System einfließen. Falls ihr Anregungen, Fragen oder inhaltliche Wünsche zu diesem weitreichenden Thema habt, dann schreibt sie mir und ich werde auf sie eingehen.

Preis: kostenlos / Pro US$ 25

Link: http://www.rememberthemilk.com/

Und Du? Auf welche Schwierigkeiten stößt Du bei Deiner Aufgabenverwaltung? Vielleicht haben die anderen Leser und ich eine Lösung? Nutzt Du etwas ähnliches oder doch ganz anderes? Lass die anderen Leser teilhaben und schreib einen Kommentar!

Verwandte Artikel:

★ Palstek, oder wie viele Gadgets braucht man

Mon, 10 Aug 2009 19:24:00 GMT

Wer schon einmal gesegelt ist weiß, wie komplex und schwierig dieser Sport ist. Ob auf einem See oder im Meer, ob Jolle oder Dreimaster, man braucht sehr viel Erfahrung, um sicher mit einem Boot zu fahren. Deshalb schaue ich gerne alten Skippern zu und lerne von ihnen so viel ich kann.

Während einer Flaute letzte Woche in der Nordsee fragte ich einen sehr erfahrenen Kapitän nach neuen Knoten — das Schweizermesser der Seefahrt. Er zeigte mir die Acht, den Mastwurf, den König der Knoten sowie ein paar andere. Leider kannte ich sie schon alle und war enttäuscht. Warum kennt er nicht mehr? Es gibt [hunderte] verschiedener Knoten und er kennt nur eine Handvoll? Er brummte nur auf Seebärenart, mehr brauche er nicht, dafür könne er sie in jeder Lage knüpfen. Punkt. Und Recht hatte er! 5 Tage auf See und man braucht wirklich keinen anderen Knoten.

Weniger ist mehr

Diese Erkenntnis lässt sich auch auf die tägliche Arbeit am Computer übertragen. Es gibt 100, 1000, unendlich viele Gadgets und jeden Tag kommen neue dazu. Doch hilft es wirklich, wenn man stets die neusten Helferlein installiert, einmal ausprobiert und wieder vergisst? Nein.

Es ist viel sinnvoller, wenige Programme zu nutzen, die mächtig wie der Palstek sind, die man gut kennt und deshalb helfen, die tägliche Arbeit effizient zu erledigen. Ich verschwende keine Zeit damit, ständig neue Tools zu installieren, sondern beschränke mich auf wenige, besonders gute Gadgets. Es sind sehr flexible und mächtige, dabei aber leicht zu bedienende Gadgets. Die wichtigsten zur Zeit sind:

Natürlich braucht man hin und wieder einen Spezialknoten oder ein Spezialgadget, aber dann schlägt man in einem [Buch] nach bzw. googlet nach dem passenden Gadget — oder man folgt dem Tweet von eiGadget.

Dennoch, weniger ist mehr. Lernt Eure Gadgets schnell zu bedienen und passt sie Euren Bedürfnissen an.

Und Du? Wie steht es um Deine Tools und Helferlein? Viele kleine oder wenige mächtige? Was hältst Du von “weniger ist mehr”? Lass die anderen Leser teilhaben und schreib einen Kommentar!

Verwandte Artikel:

★ Twitter oder wie man heute Pflanzen gießt

Thu, 06 Aug 2009 17:55:00 GMT

Dieser Artikel ist ein Gastbeitrag von Michael Gerharz.

Wie weiß ein Nerd, dass er seine Pflanzen gießen muss? Über‘s Internet, so viel ist klar. Wer aber heute richtig vorne dabei sein möchte, der lässt seine Pflanzen twittern, z.B. mit diesem Bausatz, den man bei ThinkGeek erwerben kann. Twitter ist in, so viel steht fest. Und alles, was so plötzlich in ist wie Twitter, stößt zunächst einmal auf Unverständnis.

Da geht es Twitter nicht anders als dem Handy, erst recht der SMS, Instant Messaging, Blogs und vielem mehr. Man sei ja bisher auch ganz gut ohne klar gekommen, das sei ohnehin nur ein Hype, brauche man nicht. Stimmt ja auch alles. Im Prinzip. Aber erinnert sich noch jemand daran, wie er damals gerechtfertigt hat, warum er kein Handy brauche, warum SMS schreiben albern sei und Zeitschriften lesen besser als Blogs lesen.

Dabei war eigentlich der Punkt schon immer, dass es nicht um ein „entweder-oder“, sondern um ein „sowohl-als-auch“ geht. Wer SMS schreibt, darf trotzdem noch telefonieren, wer ein Handy hat, darf es auch mal ausschalten, und wer Twitter nutzt, darf auch weiterhin eMails lesen und Blog-Artikel mit mehr als 140 Zeichen schreiben.

Was also ist Twitter für mich? Vor allem ein Platz, interessante Links und Denkanstöße zu finden, auf eine Weise die schnell und unkompliziert ist. Ich entdecke neues, das mir mein Feedreader noch nicht gezeigt hat, und umgekehrt twittere ich über interessante Fundstellen, die mir unter die Augen kommen und die etwas mit meinem Thema „Präsentieren“ zu tun haben. Und selbstverständlich sind Twitter-Leser auch gern gesehene Gäste in meinem Blog; davon gibt es mittlerweile nämlich eine ganze Menge.

Ich meine, man sollte diese ganze Twitter-Euphorie einfach entspannt sehen. Nutzen kann es jeder auf seine Weise, der eine mehr, der andere weniger und wieder ein anderer gar nicht. Und für Nerds gibt es ja mittlerweile auch eine ganze Reihe Gadgets, die Twitter zur Kommunikation nutzen, z.B. einen Fußtrittmesser für den Babybauch oder den eingangs erwähnten Feuchtigkeitssensor, der daran erinnert, dass die Blumen mal wieder gegossen werden wollen. Das ist dann übrigens auch gleichzeitig wieder altmodisch, denn man muss sich dieses Gerät selbst zusammenlöten.

Michael Gerharz ist Präsentationscoach und Autor des Blogs überzeugend-präsentieren.de, wo er wöchentlich Anregungen für bessere Präsentationen gibt.

★ ScanSnap, oder der papiertragende Überallelefant

Tue, 28 Jul 2009 08:22:00 GMT

Die Erfindung des Buchdrucks durch Johannes Gutenberg um 1442 war eine Medienrevolution und veränderte die Welt. Die Alphabetisierung begann und damit die breite Bildung der Gesellschaft. Heute sehen viele Wissenschaftler Gutenbergs Erfindung als eine der wichtigsten der Menschheitsgeschichte.

Die Auslöser der nächsten großen Medienrevolution waren der Computer und das Internet. Auch diese beiden Erfindungen veränderten die Welt, konnten das Papier aber bisher nicht verdrängen. So verbrauchten wir in Deutschland 2007 pro Kopf ca. 256 kg Papier. Dennoch ist in Zeiten des Überallbüros Papier oft unpraktisch, denn es nimmt viel Platz weg und ist schwer zu transportieren.

Das Überallbüro erlaubt es, dort zu arbeiten, wo man kreativ ist, jedoch sind Papierdokumente an einen einzigen Ort gebunden. Wie man mit Evernote und dem handlichen Dokumentenscanner S1500 von Fujitsu auch unterwegs auf seine Papierdokumente zugreifen kann, zeigt dieser Artikel.

Nicht jedes Dokument muss ins Überallbüro.
Ein Großteil unserer Korrespondenz ist papierbasiert, aber nicht jede Korrespondenz muss immer im Zugriff sein — wie viele Deiner E-Mails liest Du mehr als einmal? Ich entscheide dies anhand einer einfachen Regel: Gehört ein Dokumenten zu einem offenen Vorgang oder werde ich es vermutlich noch mal unterwegs einsehen müssen, wird es digital eingepackt. Zum Beispiel digitalisiere ich Rechnungen für Garantiefälle oder Papierbestätigungen bei Online-Vorgängen wie dem Wechsel des Stromanbieters. So halte ich alle digitalen und analogen Informationen des Vorgangs an einer Stelle zusammen. Alles andere kommt in die üblichen Ablagen. Es kostest sonst zu viel Zeit und Speicherplatz jedes Dokument zu scannen.

Die Digitalisierung muss einfach und schnell sein.
Wenn es zu lange dauert oder zu viel Interaktion erfordert, so verliere ich die Lust, mache Fehler und verzichte am Ende ganz darauf.

Der Fujitsu ScanSnap S1500 hat genau einen Knopf und er leuchtet blau — mehr nicht. Zum Starten des Scan-Vorgangs drückt man diesen Knopf. Über frei definierbare Profile der ScanSnap Software steuert man, was mit dem Scan geschehen soll. Man wählt sie leicht aus dem Menü der Taskbar (Windows) oder des Docks (Mac OS X). Diese Profile erlauben es, den Scan als JPEG-Einzelbilder, als PDF-Dokument mit mehreren Seiten und als indiziertes PDF-Dokument an beliebige Anwendungen weiterzugeben. Für die Indizierung nutzt die Software ein eigenes OCR-Modul zur Texterkennung. Damit kann man bereits sehr einfach durchsuchbare, digitale Kopien seiner Papierdokumente erstellen.

**Der Scanner arbeitet sehr zuverlässig.
**Er scannt ein 40 Seiten Dokument beidseitig in ca. 1 min. Dabei bereiten im vorher getackerte, gelochte sowie gefaltete und verknitterte Seiten kein Problem. Der Einzelblatteinzug verrichtet in allen Situationen ungestört seinen Dienst. Die OCR-Erkennung der 40 Seiten benötigt ca. 4:30.

Das Ablegen der Dokumente im Überallbüro muss automatisch erfolgen.
Die digitalisierten Dokumente müssen überall abrufbar sein. Dafür nutze ich drei unterschiedliche Profile, die die Scans direkt an Evernote weitergeben. In der kostenlosen Standardversion **** von Evernote, werden nur JPEG-Bilder per Texterkennung untersucht. Sie genügt bei einseitigen Dokumente vollauf, jedoch wird ein mehrseitiges Dokument in viele Einzelbilder zerlegt.

Dies ist aber nicht schlimm, da man über die Funktion “Merge” Notizen zusammenlegen kann, so dass am Ende nur eine Notiz mit allen Bildern entsteht. Wichtig zu beachten ist, dass man die Notizen vor dem Zusammenlegen aufsteigend nach Datum sortiert, so dass die Reihenfolge erhalten bleibt. In der Premiumversion werden seit gestern (27.07.2009) auch gescannte PDF-Dokumente per OCR verschlagwortet, so dass die oben beschriebene Routine entfallen kann.

Egal wie Evernote verschlagwortet, die Ergebnisse stehen immer **** erst einige Minuten später zur Verfügung, da die digitalisierten Dokumente erst auf die Evernote-Server übertragen, dort per OCR untersucht und wieder zurück geladen werden müssen. Dennoch ist diese Methode praktischer, da ich die OCR-Erkennung der Scanner-Software überspringe und schneller weiterarbeiten kann.

**Die Vertraulichkeit einiger Dokumente verbietet die Übertragung zu Internet-Diensten.
** Dafür nutze ich ein spezielles Notizbuch in Evernote, dass nur lokal gespeichert wird. Dafür ist aber die OCR-Erkennung der Scanner-Software nötig.

**Das Wiederfinden der Dokumente gestaltet sich Dank der zu jeder Zeit aufrufbaren Suchfunktion von Evernote sehr einfach.
**Es genügt, aus einer beliebigen Anwendung den Hotkey zu drücken und die Suchmaske wird angezeigt und alle Dokumente können durchsucht werden.

**Es gibt den Scanner sowohl in einer Windows als auch in einer Mac OS X Variante.
** Technisch sind sie identisch, jedoch unterscheiden sie sich in der beigelegten, betriebssystemabhängigen Zusatzsoftware. Da die Windows Variante günstiger ist und alle notwendigen Treiber und Dienstprogramme inklusive Texterkennung für Mac OS X mitbringt, lohnt es sich als Mac Benutzer auf die Zusatzsoftware zu verzichten und die Windows Variante zu kaufen.

Link: Fujitsu ScanSnap S1500 (PC), Fujitsu ScanSnap S1500m (Mac), Evernote

Und Du? Wie gehst Du mit Papierdokumenten um? Welche Scanner und welche Software hilft Dir, wichtige Unterlagen zu digitalisieren? Lass die anderen Leser teilhaben und schreib einen Kommentar!

Verwandte Artikel:

★ HTML-E-Mails, oder willkommen im Jahr 2009

Fri, 10 Jul 2009 11:10:00 GMT

Unsere Erfahrungen, was wir erlebt und gelernt
haben, prägen unsere Wahrnehmung und setzen uns
damit oft _gedankliche Grenzen_, derer wir uns gar
nicht bewusst sind. Aus der Psychologie ist
bekannt, dass Menschen dazu neigen, ihre
Entscheidungen in Einklang mit früheren
Entscheidungen zu treffen. Dies gilt auch dann,
wenn die frühere Entscheidung nicht optimal
gewesen ist. Nicht von ungefähr heißt es oft “Dat
ham wa scho imma so jemacht!”. Deshalb sollten wir
versuchen alte Entscheidungen und Verhaltensweisen
immer wieder zu überdenken und in Frage zu
stellen; machmal geschieht dies auch zufällig.

Vor ein paar Tagen antwortete ich auf eine längere
E-Mail und ertappte mich dabei, wie ich mit
_ASCII-Zeichen_ versuchte _Hervorhebungen_ und
_verschachtelte Listen _zu beschreiben. Keine
Frage, es wurde _unübersichtlich_. Diese
Gewohnheit stammt aus der Zeit als Bandbreite noch
teuer war und Formatierungen verpönt. Chris
Anderson
(http://de.wikipedia.org/wiki/Chris_Anderson)
beschreibt in seinem Artikel “Tech Is Too Cheap to
Meter”
(http://www.wired.com/techbiz/it/magazine/17-07/mf_freer?currentPage=all)
(eng) sehr eindrucksvoll, dass _Bandbreite heute
kostenlos_ sei und er hat Recht!

Dennoch bleiben wir unseren alten Gewohnheiten
verhaftet und schicken unsere E-Mails immer noch
wie vor 40 Jahren
(http://ueberallbuero.de/2009/06/12/drop-io-oder-der-anhang-ohne-e-mail/).
Weil wir aber wissen, dass Leserlichkeit für das
Verständnis notwendig ist, fügen wir PDF- und
Word-Dokumente in Megabyte Größe hinzu — ist das
nicht ein bisschen verrückt? Wir schauen Videos
auf _YouTube_, surfen auf _Flash animierten
Webseiten_ und verschicken unsere Urlaubsfotos per
_Web 2.0_; und doch “sparen” wir Bandbreite bei
E-Mails?

Ich bin der Meinung, es ist total verrückt und formatiere meine E-Mails mit HTML leserlich, sodass ich auf den Anhang verzichten und die Leser meine Texte direkt verstehen können. Wir leben nicht mehr in den 70ern, sondern im 21. Jahrhundert, also hinterfragt Eure Gewohnheiten, seit konsequent und schreibt doch gleich vernünftig formatiert, so wie Ihr es in Word, OpenOffice und LaTeX schon macht.

[gallery link=“file” order=“DESC” columns=“2”]

Preis: kostenlos

Link: Chris Anderson, “Tech Is Too Cheap to Meter: It’s Time to Manage for Abundance, Not Scarcity”**
**

Und Du? Sind HTML-E-Mails immer noch ein rotes Tuch für Dich und wenn ja, warum? Oder hast Du die alte Gewohnheit überkommen und schreibst E-Mails genauso wie andere Texte? Diskutier mit den anderen Lesern und mir und schreib einen Kommentar.

★ Überallakte, oder Keylogger für den ganzen Tag

Fri, 03 Jul 2009 13:32:00 GMT

Vor einigen Tagen hielt ein Kriminalbeamter des Polizeipräsidiums Bonn einen Vortrag über Computer-Forensik an der Universität Bonn. Der sympathische Beamte beleuchtete die verschiedenen Aspekte seiner täglichen Arbeit. Insbesondere zum Thema Spurensicherung blieb mir ein Schritt seiner Routine im Gedächtnis haften. Muss ein vermeintlich gehacktes System untersucht werden, so wird zu allererst ein Keylogger aktiviert. Dieser überraschende Schritt erlaubt den Polizisten selbst Wochen später genau nachzuvollziehen, was sie getan und welche Änderungen sie am System durchgeführt haben.

Ich finde diesen Ansatz auch für die tägliche Arbeit sehr sinnvoll. Ich habe beobachtet, dass ich dazu neige nur die Ergebnisse meiner Arbeit festzuhalten und nicht wie sie zustande gekommen sind. Finde ich später einen Fehler in den Ergebnissen oder möchte nachvollziehen, was ich gemacht habe, fällt es mir sehr schwer. Aus diesem Grund pflege ich nun für all meine Projekte eine digitale Akte — im Behördendeutsch auch Vorgang genannt. Mit Hilfe von Evernote sind es Überallakten.

Im Artikel “Evernote, oder der tragbare Überallelefant” habe ich Evernote bereits vorgestellt. Es ist ein internet-basiertes Gedächtnis, das Notizen zwischen verschiedenen Rechnern synchronisiert. Durch seine Integration ins Betriebssystem, können Notizen über eine Tastenkombination zu jeder Zeit wiedergefunden werden. Der Artikel “Bildnotizen, oder mehr als 1000 Worte” zeigt, wie man mit der Handykamera Fotos in Evernote einfügt, um sich später zu erinnern. Evernote nimmt in der kostenlose Version Bilder, PDFs, Webseiten und Notizen auf*. Damit lassen sich beliebige Vorgänge festhalten.

Tausch einer defekten USB-Platte

Vor kurzem ist meine USB-Platte kaputt gegangen, die ich für Backups mit Crashplan nutze. Die Abwicklung des Garantieaustausches habe ich komplett in Evernote archiviert. Bevor ich den Support des Herstellers anschrieb, legte ich eine neue Notiz an. Den Titel solcher Notizen beginne ich immer mit "Vorgang —" und beschreibe dann kurz worum es geht. Dieser Titel wandelt sich mit Zeit, um den Zustand wiederzugeben.

Die E-Mails mit dem Support kamen per Drag-and-Drop zum Vorgang. Bevor ich die defekte Festplatte verpackte, fotografierte ich sie noch mit meinem iPhone und fügte die Bilder der Evernote-Notiz hinzu. Auf diese Weise ist sowohl die Seriennummer als auch der Zustand vor dem Versand festgehalten. Den Einlieferungsschein scannte ich ein und er wurde automatisch an den Vorgang angehängt.

[gallery link=“file”]

Evernote synchronisiert die Notizen mit all meinen Rechnern und meinem iPhone. Als die Platte nach einer Woche noch nicht beim Hersteller eingetroffen war, hatte ich während der telefonischen Nachfrage sämtliche Daten parat und brauchte nur in meiner Überallakte nachzusehen, um den Einlieferungsschein als Nachweis an den Hersteller zu schicken.

Seit Donnerstag sichere ich meine Daten wieder auf der ausgetauschten USB-Platte.

Überallakten

Auf diese Weise verfahre ich den ganzen Tag. Erweitere ich ein Programm, so speichere ich die recherchierten Web-Seiten, kompliziertere Shell-Befehle und schreibe mir Notizen auf, um meine Änderungen nachvollziehen zu können. So erinnert sich mein tragbarer Überallelefant auch Wochen später noch, was ich gemacht habe.

Preis: kostenlos, Premiumversion $45 pro Jahr

Link: http://www.evernote.com

Und Du? Was hältst Du von dieser Art Arbeitsvorgänge festzuhalten? Was machst Du, um schnell den Stand eines Vorgangs einzusehen? Schreib einen Kommentar und beschreib, wie Du es machst.

*In der Premiumversion können beliebige Dateien in Evernote ablegt werden.

★ Screen, oder der immer währende Kontext

Fri, 26 Jun 2009 14:36:00 GMT

Spricht man von Multitasking, meint man das gleichzeitige Bearbeiten mehrerer Aufgaben (engl. Tasks). Der Begriff Multitasking ist aus der Informatik entlehnt und bezeichnet die Fähigkeit eines Betriebssystems mehrere Programme (Tasks) parallel auszuführen. Da die Anzahl der Tasks meist die Anzahl der Prozessoren übersteigt, unterbricht das Betriebssystem laufende Prozesse, legt sich schlafen und erweckt andere. Dafür muss es den Zustand des Tasks, den Kontext, speichern bzw. wieder herstellen.

Auch wir müssen nach einer Unterbrechung zuerst den Kontext wieder herstellen, bevor wir weiterarbeiten können. Manchmal geht der Kontext jedoch vollständig verloren. Ich lasse rechenintensive Aufgaben häufig auf Rechen-Clustern laufen und ärgere mich sehr, falls die VPN- oder SSH-Verbindung abbricht und mein Kontext verloren geht. Das Kommandozeilenprogramm screen verschafft hier deutlich Entspannung.

Screen multiplext ein physikalisches Terminal zwischen mehreren Anwendungen. Das bedeutet, man kann über eine Verbindung mehrere virtuelle Terminals (Screens) starten, in denen Programme unabhängig voneinander laufen. Der besondere Clou von screen ist: Es kann den Zustand der Screens speichern und wiederherzustellen. Verliert man die Verbindung oder möchte man von einem anderen Rechner aus weiterarbeiten, geht der eigene Kontext, die Sitzung, nicht verloren, sondern kann wieder hergestellt werden. Die Programme laufen währenddessen weiter.

Auf diese Weise kann man Kommandos auf Rechen-Clustern starten, sich abmelden und später weiterarbeiten, so als ob man die Verbindung nie unterbrochen hätte. Im Folgenden die wichtigsten Kommandos von screen.

Installation und Konfiguration
Screen ist in allen aktuellen Linux-Distributionen enthalten und kann über das Paketmanagement installiert werden. Für Mac OS X kann man es aus den Mac-Ports installieren. Gestartet wird es durch Eingabe von screen auf der Kommandozeile. Die Interaktion mit screen findet über Tastenkombinationen statt, die mit CTRL-A beginnen. Da diese Kombination in der bash zum Sprung an den Anfang der Eingabe genutzt wird, nutze ich CTRL-X. Zusätzlich sollte man vor Aufrufen von screen den Terminal-Typ auf “screen” ändern, damit Sonderzeichen korrekt verarbeitet werden. Für die bash nutze ich folgenden Alias:
alias screen=‘TERM=screen screen -e^Xx’

Mehrere Screens
Möchte man ein weiteres Screen öffnen, so gibt man CTRL-X-C ein. Der Name des neuen Screens entspricht dem gestarteten Programm; in den meisten Fällen also “bash”. Dieser lässt sich durch CTRL-X-SHIFT-A jedoch ändern, so dass in der Übersicht aller offenen Screens leichter navigiert werden kann. Die Übersicht ruft man mit CTRL-X-" auf. Das direkte Anspringen eines bestimmten Screen geht mit CTRL-X-[0-9].

**Speichern der Sitzung
**Möchte man eine Sitzung speichern bzw. in die original Shell aus der man Screen gestartet hat zurückkehren, gibt man CTRL-X-D (für detach) ein. Die Sitzung wird aber auch gespeichert, sollte die Verbindung getrennt werden.

**Wiederherstellen der Sitzung
**Nach Eingabe von screen wird grundsätzlich eine neue Sitzung gestartet. Möchte man eine alte Sitzung wieder herstellen, so kann man sich mit screen -ls (für list) die gespeicherten Sitzungen anzeigen lassen und mit screen -r <pid> aufrufen. Ist nur eine Sitzung aktiv, genügt die Eingabe von screen -r (für re-attach).

**Weitere Funktionen und Hilfe
**Screen kann noch sehr viel mehr. Zum Beispiel unterstützt es Copy-And-Paste zwischen Screens. Eine Übersicht aller Befehle bekommt man durch Eingabe von CTRL-X-?.

**Übersicht der wichtigsten Kommandos
**

screen: Starte eine neue Sitzung
screen -ls: Zeigt gespeicherte Sitzungen
screen -r: Stellt eine Sitzung wieder her
CTRL-X-C: neues Screen öffnen
CTRL-X-SHIFT-A: Namen ändern
CTRL-X-": Übersicht über offene Screens
CTRL-X-[0-9]: Anspringen eines Screens
CTRL-X-D: Sitzung speichern und Screen beenden
CTRL-X-?: Hilfe

Preis: kostenlos — GPL lizensiert

Link: http://www.gnu.org/software/screen/

Und Du? Wie begegnest Du unzuverlässigen VPN-Verbindungen und rettest Deinen Kontext? Hast Du schon Erfahrung mit screen? Lass die anderen Leser teilhaben und schreib einen Kommentar!

★ Bildnotizen, oder mehr als 1000 Worte

Fri, 19 Jun 2009 12:59:00 GMT

Gedanken schnell und zuverlässig festzuhalten ist die Grundlage von kreativer Arbeit. Im Artikel “Ideen sind überall, oder auf Hemingways Spuren” habe ich über das analoge Gadget “Notizbuch” berichtet; besonders die Überalleinsetzbarkeit und das formlose Aufschreiben machen ein Notizbuch zum wertvollen Begleiter. Neben Stift und Notizbuch braucht man zum Einsatz dieses Gadgets nur noch eine Hand zum Schreiben.

Jedoch sind Hände keine Selbstverständlichkeit: Wer täglich mit einer Maus und Tastatur arbeitet riskiert an unergonomischen Arbeitsplätzen eine Sehnenscheidenentzündung*. Für uns Nerds ist eine Entzündung an den Handgelenken eine Katastrophe, denn ohne Hände können wir überhaupt nicht arbeiten — weder praktisch am Computer noch konzeptionell auf Papier.

Kann man nicht mehr schreiben, so hilft das Sprichwort “Ein Bild sagt mehr als tausend Worte” weiter. Warum nicht ein Foto mit der Handykamera festhalten, als umständlich zu umschreiben, woran man sich erinnern will? Mit Evernote werden aus Fotos digitale, überall zugreifbare Notizen.

In vielen Fällen ist es sinnvoller einen visuellen Eindruck auch visuell zu speichern, anstatt schriftliche Erinnerungsstützen zu bauen. Dies gilt insbesondere, wenn man nicht genau weiß, was man aufschreiben soll: “Wie heißt die Pflanze, die ich kaufen wollte”, “Wie heißt der Lieblingskäse meiner Freundin” oder “Welcher Reisessig schmeckte beim letzten Sushi so gut?”.

Ich habe Evernote im Artikel “Evernote, oder der tragbare Überallelefant” vorgestellt. Es ist ein internet-basiertes Gedächtnis, das Notizen zwischen verschiedenen Rechnern synchronisiert. Durch seine Integration ins Betriebssystem, können Notizen über eine Tastenkombination zu jeder Zeit wiedergefunden werden. Evernote ist nicht auf Computer beschränkt, sondern es gibt auch mobile Versionen für Windows Mobile, iPhone, Blackberry und Palm Pre. Eine Version für Android ist angekündigt. Evernote kann die eingebaute Handykamera direkt nutzen, aus Fotos neue Notizen zu erstellen. Es versucht sogar den Text in Bildern zu erkennen und zum Volltextindex hinzuzufügen.

Für den letzten Wein- und Käseabend habe ich dem Weinhändler einfach Bilder der Flaschen gezeigt, die ich wollte, anstatt das Etikett abzuschreiben. Genauso habe ich es an der Käsetheke gemacht:[gallery link=“file” order=“DESC”]

Also auch mit einer Sehnenscheidenentzündung muss man nicht auf Wein und Käse verzichten, wenn man die richtigen Gadgets nutzt. Versucht es selbst, manchmal sagen eben Bilder wirklich mehr als tausend Worte .

Preis: kostenlos, Premiumversion $45 pro Jahr

Link: http://www.evernote.com

Und Du? Wie verwaltest Du Notizen, Wissen und Links? Nutzt Du vielleicht schon Evernote und wie hilft es Dir? Lass die anderen Leser teilhaben und schreib einen Kommentar!

*Im September 2006 stufte das Verwaltungsgericht Göttingen die Sehnenscheidenentzündung als Berufskrankheit ein, falls Arbeitnehmer überwiegend am Computer arbeiten (Az: 3 A 38/05). Wird die Entzündung nicht konsequent auskurieret, besteht die Möglichkeit einer chronischen Erkrankung (RSI-Syndrom).

★ Drop.io, oder der Anhang ohne E-Mail

Fri, 12 Jun 2009 15:57:00 GMT

Die E-Mail wurde noch vor dem Internet 1965-66 entwickelt und ermöglichte anfangs nur den Informationsaustausch zwischen Nutzern desselben Großrechners — eine revolutionäre Technologie*; damals. Heute ist E-Mail selbstverständlich und aus dem elektronischen Brief ist ein elektronischer Paketdienst geworden: Möchten wir ein Dokument übertragen, schreiben wir eine E-Mail, hängen die Datei an und “Senden”.

E-Mails wurden jedoch für den Austausch von Text konzipiert und nach diesem Konzept arbeiten sie noch heute. Deshalb müssen Dokumente für den Versand erst umgewandelt werden. Dies bläht die Dateien stark auf und überlastet manchmal das E-Mail-System: “552 5.2.3 Message size exceeds fixed maximum message size”? Man hat also vergebens auf die Übertragung der E-Mail gewartet und muss nun von vorne anfangen.

Die Antworten auf diese Fehlermeldung sind häufig, “Verschicke mehrere E-Mails” oder “Kopier’ es auf einen USB-Stick”. Ich sage, probieren wir etwas Neues und verschicken den Anhang direkt ohne E-Mail. Drop.io ist ein Web-Dienst für den Austausch von Dateien, eine Art Postkorb im Internet. Dieser Postkorb wird bei drop.io “Drop” genannt und wird automatisch beim Besuch der Seite erzeugt. Drop.io schlägt einen kryptischen Namen wie “xfjwgtv” vor und der neue Drop ist damit unter “http://drop.io/xfjwgtv” zu erreichen. Man kann aber auch einen eigenen Namen vergeben, er muss jedoch größer als 7 Zeichen sein.

Ist der Drop benannt, wählt man die zu verschickenden Dateien aus und “Senden” — wie E-Mail, nur schneller und ohne Fehlermeldung. Nachdem der Drop gefüllt ist, kann man den Link zum Drop per E-Mail verschicken und die Adressaten können auf die Dateien zu greifen. Man kann Daten natürlich auch wieder aus dem Drop löschen oder neue hinzufügen. Drops werden 1 Jahr nach dem letzten Zugriff automatisch gelöscht, so dass man sich nicht um die Entsorgung kümmern muss.

Ein Drop ist auf eine Größe von maximal 100 MB beschränkt, man kann aber zusätzlichen Speicherplatz mieten, falls man Bedarf hat. Die Anzahl der Drops ist unbeschränkt.

**Sicherheit
**Nachdem der Drop erzeugt worden ist, kann man ein Administrationspasswort und eine E-Mail-Adresse zur Wiederherstellung des Passworts nach Verlust angeben. Möchte man die Daten vor Außenstehenden schützen, falls jemand den Namen des Drops errät, kann man den Drop mit einem Zugangspasswort schützen. Dies kann man direkt bei Erzeugung des Drops angeben oder auch später.

Zusammenarbeit
Drop.io bietet viele Möglichkeiten zur Zusammenarbeit mit Anderen. Man kann einen Chat starten und so über Dokumente sprechen, man kann mittels RSS und E-Mail über Änderungen an Drops informieren und vieles mehr.

Integration
Nutzt man Drop.io häufiger gibt es kleine Anwendungen zum noch einfacheren Arbeiten mit Drops; zum Beispiel gibt es eine Firefox-Integration, die per Drag-and-Drop Dateien in einen Drop ablegt oder eine iPhone-Anwendung

Für Nerds
Für den Informatiker bietet Drop.io ein Ruby-basiertes Kommandozeilen-Interface, so dass man Drops per Skripts steuern kann.

Also, anstatt Pakete umständlich in Briefformat zu pressen, verschick Deine Urlaubsfotos beim nächsten Mal direkt ohne E-Mail. Oder hinterlege Deine Präsentation bei drop.io, bevor Du zur Konferenz fliegst.

Preis: kostenlos bis 100 MB, $10 für jedes weitere GB pro Jahr

Link: http://drop.io
Extra-Links: Firefox-Plugin, iPhone-Anwendung, Ruby CLI

Und Du? Wie verschickst Du große Dateien? Nutzt Du andere Dienste, die vielleicht besser sind oder etwas besser machen als Drop.io? Lass die anderen Leser teilhaben und schreib einen Kommentar!

*Die erste deutsche E-Mail wurde am 2. August 1984 übertragen

★ Dropbox, oder das Überallregal

Fri, 05 Jun 2009 13:54:00 GMT

Ich liebe Bücher, besonders Fachbücher! Doch leider gilt das berühmte Zitat: “Es wäre gut Bücher kaufen, wenn man die Zeit, sie zu lesen, mitkaufen könnte, aber man verwechselt meistens den Ankauf der Bücher mit dem Aneignen ihres Inhalts.”* Also kaufe ich sie auf Verdacht, stelle sie ins Bücherregal und warte bis sie mir weiterhelfen können.

Doch wenn ich dann auf ein konkretes Problem stoße, mir einfällt zu diesem Thema ein Buch gekauft zu haben, stelle ich oft fest, es steht im falschen Bücherregal. Bin ich im Büro, so steht das wichtige Buch zu Hause und zu Hause vermisse ich immer die Bücher aus dem Büro. Dieses Problem kennt jeder von uns; insbesondere wenn es um unsere Daten geht: Die Powerpoint-Präsentation ist auf dem falschen Rechner, wo liegt die neue Version des Dokuments und wie passen die Änderungen von zu Hause zu den Änderungen im Büro? Hier setzt Dropbox an und synchronisiert Daten zwischen beliebigen Rechnern.

Dropbox synchronisiert stets mit einem Internet-Speicher, so dass die eigenen Rechner nicht ständig eingeschaltet sein müssen. Die Synchronisation geschieht automatisch und für den Nutzer unbemerkt. Dropbox ist sehr einfach nutzbar und verzichtet konsequent auf komplizierte Programmfenster. Es integriert sich nahtlos als einfacher Ordner ins Betriebssystem. Alle Dateien, die man in diesen Ordner kopiert oder in ihm angelegt, werden automatisch synchronisiert. Besteht gerade keine Internet-Verbindung, dann wartet Dropbox, bis es wieder auf seine Server zugreifen kann.

Für den Benutzer besteht keinen Unterschied, ob man reguläre oder von Dropbox überwachte Dateien auf seinem lokalen Rechner bearbeitet. Kommt man aus dem Büro nach Hause und schaltet den Rechner an, findet man nach kurzer Zeit alle Dokumente in der aktuellen Version vor.

Dropbox überschreibt geänderte Dateien nicht einfach, sondern versioniert sie, so dass man stets Zugriff auf überschriebene oder sogar gelöschte Dokumente hat. Möchte man auf Revisionen zugreifen, startet man aus dem Dropbox-Menü das Web-Interface, welches die Revisionen anzeigt. Durch dieses Web-Interface kann man zusätzlich auch von überall mit einem Internet-fähigen Gerät auf seine Dokumente zugreifen.

Drobox verschickt nur Änderungen von Dateien, so dass keine Bandbreite verschwendet wird. Die Übertragung geschieht gedrosselt und erlaubt dadurch ungestörtes Arbeiten mit dem Internet. Zur Sicherheit werden die Daten mit SSL verschlüsselt transportiert. Es wird konsequent das HTTP-Protokoll über Port 443 genutzt, so dass gängige Firewalls kein Hindernis für den Einsatz von Dropbox sein sollten. Auf den Servern werden die Daten ebenfalls verschlüsselt abgelegt, jedoch kennt Dropbox den zugehörigen Schlüssel. Dies ist notwendig, um die Versionierung zu ermöglichen. Wer zusätzliche Sicherheit wünscht, kann Truecrypt** einsetzen. Mehr Informationen findet man auf den Hilfeseiten von Dropbox.***

Wer möchte, kann einzelne Dateien öffentlich freigeben und auf diese Weise mit Anderen austauschen. Dropbox bietet auch ein spezielle Funktion zum automatisch Erstellen von Fotogalerien.

Dropbox gibt es in einer kostenlosen Variante mit 2 GB Speicherplatz (s. Extra-Link unten). Ich komme mit 2 GB sehr gut aus, denn ich hinterlege nur die Dateien, die ich zur Zeit bearbeite. Benötigt man mehr Platz, kann man 50 und 100 GB Speicherplatz pro Jahr mieten. Dropbox ist unter Windows, Mac OS X und Linux nutzbar. Zusätzlich gibt es ein Web-Interface.

Mit Dropbox hat man sein Dateiregal immer dabei, egal wo man ist und stets aktuell.

Preis: 2 GB kostenlos, 50 GB $99 pro Jahr, 100 GB $199 pro jahr

Link: http://www.getdropbox.com/
Extra-Link: lass Dich von mir werben und bekomm zusätzlich 250 MB

Und Du? Wie synchronisierst Du Dateien zwischen Deinen Rechnern? Nutzt Du andere Tools, die vielleicht besser sind oder etwas besser machen als Dropbox? Lass die anderen Leser teilhaben und schreib einen Kommentar!

*Arthur Schopenhauer (1788-1860)

**Mehr zu Truecrypt in einem zukünftigen Artikel.
***Dropbox hat angekündigt in Zukunft auch vom Benutzer erstellte Schlüssel zu unterstützen.

★ Evernote, oder der tragbare Überallelefant

Fri, 29 May 2009 11:15:00 GMT

Elefanten erinnern sich sprichwörtlich an alles. Ein solches Gedächtnis wünscht man sich selbst. Zum Beispiel, wenn nach einem Brand Unterlagen zerstört worden sind. Wer dann kein Backup hat ist verloren oder fragt seinen Kollegen. So fragte mich ein Kollege nach einer Referenzkarte für VIM, die sich in Rauch aufgelöst hatte.

Es muss aber nicht brennen, um ein Elefantengedächtnis sinnvoll einsetzen zu können. Wer sich traut ein bisschen analog zu sein und ein Notizbuch zum Festhalten seiner Ideen nutzt, wird schnell feststellen, dass Festhalten nur die halbe Miete ist. Man muss sie auch wieder finden und bearbeiten können, damit man seinen Kollegen helfen kann.

In beiden Fällen hilft Evernote: Ein tragbares, durchsuchbares Gedächtnis. Kombiniert man seine analogen Notizen mit Evernote, findet man sie schnell und an jedem Ort der Welt wieder. Evernote-Notizen werden zentral im Internet gespeichert, so dass sie überall abrufbar sind. Jede Notiz wird volltextindiziert, so dass man nicht auf Stichwörter oder Überschriften angewiesen ist. Bilder unterzieht Evernote einer Texterkennung, so dass enthaltener Text ebenfalls durchsuchbar ist. Das Besondere an Evernote ist, dass die Notizen zentral gespeichert, aber lokal auf die eigenen Rechner synchronisiert werden. Auf diese Weise gibt es keine lästigen Verzögerungen durch Internet-Zugriffe, die im Hintergrund für den Nutzer unbemerkt stattfinden.

Die Integration von Evernote ins Betriebssystem macht es sehr leicht das eigene Notizbuch zu durchsuchen und neue Notizen hinzuzufügen. Es gibt eine Tastenkombination, die zu jeder Zeit ein Fenster zum Durchsuchen der Notizen öffnet. Häufig stößt man beim Lesen im Web auf Dinge, die man festhalten möchte. Dafür gibt es für die gängigen Browser einen Schnellstartknopf, der entweder die ganze Seite oder nur markierte Inhalte samt Bildern, der URL und Überschrift als neue Notiz in Evernote einfügt. Oder, Evernote macht einen Screenshot, schneidet ihn zurecht und fertig ist die Notiz.

Notizen werden im Klartext gespeichert, um das Durchsuchen und die Texterkennung zu ermöglichen. Möchte man jedoch auch vertrauliche Informationen speichern, so kann man einzelne Notizen oder Teile davon verschlüsseln.

Zur Zeit gibt es die Software für Windows und Mac OS X; für unterwegs auch für iPhone, Windows Mobile und Blackberry bzw. online per Web-Client. Auf diese Weise hat man seine Notizen immer dabei, egal wo man ist.
Wine hilft, um die Software auch unter Linux nutzen zu können.

In der Basisversion ist Evernote kostenlos mit einem monatlichen Transfervolumen von 40 MB. Das klingt nach wenig, ich habe aber im letzten Jahr nie mehr gebraucht und nutze es täglich. Die Notizen sind auf Bilder, Audio, PDF und Text beschränkt. Die erweiterte Premiumversion bietet Verschlüsselung der Übertragungen per SSL, hat keine Einschränkung von Dateitypen und die Texterkennung von Bildern wird mit einer höheren Priorität ausgeführt. Das monatliche Transfervolumen beträgt 500 MB.

Mit Hilfe von Evernote konnte ich meinem brandgeschädigten Kollegen schnell helfen: Ich rief das Durchsuchenfenster auf, gab “VIM” ein, wählte die Referenzkarte und druckte sie aus. Keine 2 Minuten Arbeit und mein Kollege lächelte wieder — ein guter Tag.

Preis: kostenlos, Premiumversion $45 pro Jahr

Link: http://www.evernote.com

Und Du? Wie verwaltest Du Notizen, Wissen und Links? Nutzt Du vielleicht schon Evernote und wie hilft es Dir? Lass die anderen Leser teilhaben und schreib einen Kommentar!

★ Ideen sind überall, oder auf Hemingways Spuren

Fri, 22 May 2009 19:20:00 GMT

Es ist schlau, von schlauen Menschen zu lernen. Einer dieser Menschen war sicherlich Ernest Hemingway, ein begnadeter Schriftsteller, Journalist und Zeitzeuge. Er diente als Sanitäter im Ersten Weltkrieg, berichtete während des spanischen Bürgerkriegs aus Katalonien und erhielt für seine Arbeiten den Pulitzerpreis und den Nobelpreis für Literatur. Hemingway lebte von Ideen und Einfällen.

Unsere Ideen sind es, die uns von anderen unterscheiden und sie kommen zu seltsamen und überraschenden Augenblicken, ohne dass man es erzwingen oder kontrollieren kann. Wer kennt nicht die Situation, den ganzen Tag erfolglos an einem verzwickten Problem gearbeitet zu haben und die Lösung 10 Minuten nachdem man sich unter die Decke gekuschelt plötzlich ganz klar und deutlich vor Augen zu haben?

Doch was tut man, wenn man eine Idee hat, wenn ein Einfall kommt? Aufschreiben! Hemingway hatte immer ein Notizbuch, ein Moleskine bei sich*****, in das er seine spontanen Einfälle und Eindrücke notierte. Und wie macht man das in unserer digitalen (Nerd-)Welt? Genauso!

Das Festhalten von Ideen und Einfällen muss schnell und einfach sein, es darf den Arbeitsprozess nicht zu lange unterbrechen. Digitale Werkzeuge müssen aufgerufen, entsperrt, und gestartet werden. Malen und Schreiben sind die Ausdrucksformen, die wir seit dem Kindergarten lernen und am besten können. Es ist am einfachsten für uns damit Gedanken festzuhalten. Darin liegt die Stärke von Stift und Papier. Mal genügt ein kurzes Wort, eine kleine Zeichnung oder eine Zahl — ganz ohne Schrifterkennung und T9. Und besonders ohne Startzeiten.

Ich nutze karierte “Cahier Journal” Notizbücher von Moleskine. Sie passen in meine Gesäßtasche (A6), sind sehr flach (64 Seiten) und außerordentlich robust. Wenn ich einen spontanen Einfall habe, zücke ich es, mache eine Notiz und arbeite dann direkt weiter. Auf diese Weise behalte ich den roten Faden und verliere keine Zeit, mich wieder eindenken zu müssen (für Nerds: kein Prozesswechsel, der Kontext bleibt erhalten)**.

Also, traut Euch, es muss nicht immer ein digitales Gadget sein, seid analog!

Link: Cahier Journal von Moleskine

Und Du? Welche Tricks setzt Du ein, um den Kopf frei und die Ideen fest zu halten? Schreib doch einen Kommentar!

***Die Marke “Moleskine” gibt es erst seit 1996, so dass es wohl eher eine Legende ist; aber es war ein ähnliches.

**Mehr zum unterbrechungsfreien Arbeiten wird es in zukünftigen Artikeln geben.**

★ Crashplan, oder wenn es doch mal brennt

Thu, 14 May 2009 10:38:00 GMT

Letzte Woche brannte es bei uns. Es ist nichts Schlimmes passiert, der Brand blieb im betroffenen Büro, jedoch zog der entstandene Rauch in alle anderen Büros, sodass zum Gesundheitsschutz sämtliche Büros unserer Abteilung nicht betreten werden dürfen.

Informatiker predigen und dozieren, man solle Backups seiner Daten machen, sie an einem sicheren Ort langen, kichern dann und ignorieren ihre eigenen Ratschläge. So war auch unter meinen Kollegen der Ärger groß, denn wichtige Daten sind nur auf den Arbeitsplatz-PCs gespeichert. Es fehlte meine Kollegen ganz offensichtlich an einem Plan für einen solchen Crash.

Crashplan ist eine Backup-Software die verteilte, d.h. an mehreren Stellen gelagerte, tägliche Backups automatisch erstellt. Backups können bei Freunden (anderen Crashplan-Nutzern), weiteren eigenen Rechnern, lokalen Verzeichnissen (USB-Platten) und online bei Crashplan abgelegt werden. Die einzelnen Backups werden inkrementell und ** versioniert angelegt. Dies bedeutet, dass nur Änderungen übertragen werden, diese aber einzeln wiederherstellbar sind. Auf diese Weise kann man auf unterschiedliche Versionen eines Dokuments zurückgreifen. Die Backups werden auf Wunsch verschlüsselt übertragen und gespeichert.

Die Besonderheit von Crashplan ist seine einfache Handhabbarkeit, die beispiellos für Backup-Programme ist. Jeder, der professionelle Software zur Datensicherung einsetzt, kennt die Dissertationen und Bücherserien, die man lesen und verstehen muss, bevor man überhaupt weiß, wie man die Programme startet. Crashplan ist für jeden Nutzer direkt und einfach einsetzbar. Es erkennt, wenn ein Backup-Ziel erreichbar ist, egal ob ein ferner PC oder eine UBS-Platte, und beginnt mit der Sicherung.

Durch die kostenlose Verbindung aller Crashplan-Instanzen mit dem Online-Dienst von Crashplan, erhält man per E-Mail Warnungen, falls Geräte längere Zeit nicht erfolgreich gesichert werden konnten.

Crashplan ist einfach zu bedienen, sehr effizient, bietet hohen Daten- und Informationsschutz und ist die beste Backup-Lösung für, die ich bisher kennengerlent habe. In der kostenpflichtigen Variante “Crashplan+” werden Backups kontinuierlich bei Veränderung von Daten erstellt, sodass jede Änderung an den eigenen Dokumenten rückgängig gemacht werden kann. Zusätzlich gibt es noch “Business”-Versionen für Unternehmen mit deutlich erweiterten Funktionsumfang und Preis.

Crashplan gibt es für Windows, Mac OS X, Linux und man kann Backups zwischen allen Betriebssystemen austauschen.

Preis: kostenlose private Nutzung, 1-10 Computer, online Speicherplatz ab $49,80 für 50 GB / Crashplan+ $59.99

Link: http://www.crashplan.com/consumer/index.html

Ähnliches: Twins (Mac OS X), Syncplicity (Windows und Mac OS X)

Lukas Pustina - Notes

★ The Real Battle in Local LLM Setup Isn’t the Model

Why GC sometimes beats Rust

Can a function with no body be useful, yes!

Rust: Elevator Pitch for impl Trait

What is DevOps

How colors influence ls's speed and doors open

Vimways - A Vim-themed advent calendar

Looking at TDD: An Academic Survey

★ Where Vim came from or why I prefer Vim

Pointers Are Complicated, or: What’s in a Byte?

Goodbye Microservices: From 100s of problem children to 1 superstar

Rust stabilized try_fold and try_for_each

From &str to Cow

The Problem You Solve Is More Important Than The Code You Write

The Secret Life of Cows

★ Revisiting Rust’s Function Pointers

Option is a Generic Type

Fn, FnMut, and FnOnce are Traits

Primitive Type fn

Summary

You’re Doing Scrum Wrong, and Here’s How to Fix It

Adopt Microservices?

Developers Should Abandon Agile

The Rise of Rust in DevOps

Docker or Glueing together Stuff you don’t Understand

You’re Not Actually Building Microservices

Uncle Bob about FP vs. OO

CPU Utilization is Wrong

There is no Production or Test Code - just Product Code

Go: the Good, the Bad and the Ugly

★ Cloud Fibel 2.0

Cloud Fibel 2.0

Inhalte

Frei verfügbar!

Effectively Using Iterators In Rust

Iter

IntoIter

How for Loops Actually Work

core::iter::Cloned

Strategies for solving ‘cannot move out of’ borrowing errors in Rust

1. Block

2. Closure

3. Function

★ Docker basiertes Runtime Environment for Developers

RED bei CenterDevice

Technische Umsetzung

Zukunft

Es gibt noch mehr

★ An OpenStack Crime Story solved by tcpdump, sysdig, and iostat – Episode 3

Footnotes

★ An OpenStack Crime Story solved by tcpdump, sysdig, and iostat – Episode 2

★ An OpenStack Crime Story solved by tcpdump, sysdig, and iostat - Episode 1

Footnotes

★ Drei Tage ScalaDays 2014 im Überblick

★ Provisioning IaaS Clouds with Dynamic Ansible Inventories and OpenStack Metadata

Inventories in a Static World

Inventories in a Dynamic World

Metadata for OpenStack Virtual Machines

Dynamic Inventories for Ansible

Querying OpenStack Metadata with Python

Using Multiple Inventories for Ansible

There is more

★ Crypto is Broken or How to Apply Secure Crypto as a Developer

Hybrid Encryption

It’s Bad — The Assembler For Crypto Code

It Gets Worse — The Black Magic

Abstraction to the Rescue — NaCl

Opinionated Library

Salty API

libsodium

Shick Crypto Library

There’s more

Footnotes

★ Ceph Object Storage as fast as it gets or Benchmarking Ceph

Footnotes

★ Docker Registry or How to Run your own Private Docker Image Repository

Tags

Registry

Demo

`Option` is a Generic Type

`Fn`, `FnMut`, and `FnOnce` are Traits

Primitive Type `fn`

`core::iter::Cloned`