Recent blog posts
This is our new blog page. If you're looking for posts before 2012, see our archive.
I was looking at the code for the Dragon Curve and it struck me that this should be an easy fractal to represent in PDF. Even though the curve is usually represented with relative moves and turns which are trivial in PDF, I chose to stay closer to some of the examples in Rosetta Code to keep it consistent with their examples, if you wanted to side-by-side them. This is a great basic example on how to use DotPdf for generating graphics on a page.
The first thing was a class that wraps the Dragon curve code. There is one main entry that returns a PdfPath that represents the curve. You could parameterize it further by exposing length and split.
public class Dragon
{
private static double _sqrt2 = Math.Sqrt(2.0);
private PdfPath _path;
private double _angle;
...
In this article, I’m going to talk about 80s era file formats and ways you can support them in .NET and keep your code sane, safe, and short, but to start, let’s talk about data file formats and why they are the way they are or were the way they were.
First, let’s consider why we even have data files. Persistence of data is one reason, but historically you would frequently see data files built because you couldn’t keep the entire dataset in memory. In the dim dark ages, you were lucky if you had virtual memory (I’m looking at you, Macintosh System 6 and earlier) or if it was lousy (I’m looking at you Windows 3.1 and earlier), so you would try to keep your memory footprint low. The obvious solution is to dump things to a temporary file then read them back in later when you needed them again. The trick is that you want to incur as little overhead as possible, so your reading and writing code had to be simple. A typ...
)
Note: prize offer at the end of this post! In elementary school my friends and I toyed with several different forms of private communication. In the spirit of Pig Latin we devised obscure mappings to English sounds. We used these systems to speak privately in public spaces. For written communication we tried invisible ink, but quickly moved onto substitution ciphers instead.
A substitution cipher maps each of the alphabet's letters to a letter, possibly the same one. Additionally, no pair of letters can map to the same letter. Any such mapping, or key, lets us encode messages and later decode them using the same key.
Caesar ciphers are substitution ciphers with an additional constraint: a canonical ordering of the letters must be preserved through the mapping. To clarify, suppose we're making a substitution cipher where 'A' maps to 'X'. English has a canonical ordering for its letters where 'B' comes af...
DotPdf comes with a number of built-in shapes and as I mentioned in a previous blog, it’s easy to define new shapes. It’s very easy to make shapes, but sometimes we can get carried away and lose sense of what should be a shape and what should not be a shape. This blog is going to be about guidelines for categorizing your page elements and infrastructure for making large-scale document production easier.
First, let’s talk about what makes a shape. A shape should be:
Simple to represent in data (ie, you should be able to attach the [Serializable] attribute and not worry about what happens with default behaviors)
It should be blissfully unaware of the page on which it sits (or more precisely the drawing list in which it resides)
It should have absolutely no business logic
Now, let’s talk about what makes a shape generator. A shape generator can/should be:
Simple or complex in data representation (it may pull...
I spent most of last week on web archeology, puzzling out how to unit test an ActiveX control, entirely dynamically, from C# inside the NUnit framework.
The EZTwainX ActiveX control is a control I created a few years ago at Dosadi, first and foremost a wrapper for the TWAIN scanning API, allowing a web application to scan from a user’s local scanner. Secondarily EZTwainX is an image container, able to collect, display, modify, print and export images as base64 strings to Javascript, ready for upload.
When Atalasoft hired me, they purchased EZTwainX and incorporated it into some of their offerings. And one of the things Atalasoft does a lot of is unit-testing, so EZTwainX needed a solid unit-test. (At this point the TWAIN/scanner geeks might be wondering “Wait… like, automated tests of TWAIN scanning?” – Yes, that too. A good subject for a future blog.)
What I wanted was a C# class that would carry out a series of automated tests of a fre...
Software engineers don’t develop products in a vacuum. We rely on high-level languages, frameworks, and SDKs to get the job done. Even those who create drivers, operating systems, or virtual machines in assembler are confined to the instruction set supported by the target processor. Every engineer in our industry stands on the shoulders of giants.
How can we be sure our tools will always behave as expected? In truth, it’s rarely feasible to be completely sure they all will. Intel once released a processor that divided only 0.0000000114% of the total input number space incorrectly. Operating systems and applications seemed to run just fine on it, but a math professor eventually reduced strange results to a bug in the processor. Have you tested your processor’s entire instruction set on all possible inputs and confirmed that all results are correct? What about doing the same for the JIT compiler, IL, .NET Framework...
Bob Moesta from The Rewired Group has a framework for thinking about how customers change which product/service they are using to get a job done:
Force 1: Push of the situation – something is happening that is making the customer think about switching
Force 2: Pull of the new solution – all of the benefits that the new solution appears to offer
Force 3: Allegiance to the current behavior – the comfort and understanding of the current solution
Force 4: Anxiety of the new solution – the risk in changing
Bob’s theory is that you need to make F1 + F2 > F3 + F4. To do this, you must know what the old behavior is, what the forces are for that behavior, and then figure out what you can do to address them (increase F1 and F2, and decrease F3 and F4)
I will analyze a specific case in my market (developer toolkits) to show you how to use the framework.
Case:
The customer is an ISV with a product that could be enhanced ...
One of the main ways of creating page content in DotPdf is to use shapes. We give you a number of “canned” shapes that are very easy to work with (circle, rectangle, path, text, etc.), but you will probably need to make your own shapes at some point. This article is going to show you one way to do that that is very easy.
Let’s say that you need to create a letterhead that needs to have a donut in the logo. You could just draw the donut directly, but let’s say that you’re trying to create a whole corporate presence around donuts and you need to draw a lot of donuts in a lot of places. The way to do that is to make a shape.
What is a donut? It’s two circles of different radii drawn at the same center with a fill color and an outline color. Great – these feel like things to pass to the constructor and for some properties. We’ll start by making a Donut class that is a subclass of Pd...
Since we are moving to a new blogging platform (and not moving the posts over) I thought it was a good opportunity to reflect back at some blog posts I’ve written since I started blogging about 7 years ago during the early years of Atalasoft. Even as the author, it’s interesting to read about our progress and my take on it. Please Enjoy!
2006
Venture Funding vs. Bootstrapping
On of my first blog posts about why not to take VC. As you might imagine, I’m pretty happy that we didn’t take on outside investment.
Inception of a Company Name
This is how the name Atalasoft came to be. It goes into more detail than I give when people ask me in-person, and some helpful tips if you’re thinking about a brand name yourself.
New Office – One Week to Go!
We started with a lot of room to grow. Now we completely fill the space! My office window still has a great view of Mt Tom.
From Nothing to Something
Talks about how I started Atalasoft. Who...
Hi, my name is Spike McLarty, and I’m a Senior Software Architect here at Atalasoft. I joined the company in January 2010 after running my own one-man company for a decade or so, out on the Left Coast on an island near Seattle. While I have a fair amount of experience across the spectrum of nuts-and-bolts image processing, my particular specialties are some of the old-school technologies: The TWAIN scanning API, imaging file formats like TIFF, GIF, JPEG, PNG and PDF, C and C++ coding, the native Win32 API, COM and ActiveX. When I’m not working on scanning and image processing, I study cognitive psychology and linguistics from a computer-modeling perspective.
I plan to blog a mix of practical coding tips (the classic “don’t let this thing that just bit me bite you”), speculation about how this or that problem could be solved with computers and software, and accounts of the small epiphanies I have every now and then while studying l...