Stellenticket HTWK Leipzig

About this job

We are look­ing for smart, cre­at­ive developers with a solid the­or­et­ical back­ground. Our team of developers con­sists of those with 15+ years of com­mer­cial exper­i­ence in vari­ous fields, to fresh gradu­ates in Com­puter Sci­ence, Phys­ics and Math­em­at­ics. A uni­versity degree or work exper­i­ence with C++, together with a fresh and cre­at­ive prob­lem-solv­ing approach would be an excel­lent com­bin­a­tion for this role. As all of our recruit­ment steps are task-based, the selec­tion is based on the skills demon­strated dur­ing our tests.

You will work largely inde­pend­ently and will be respons­ible for the whole range of activ­it­ies when imple­ment­ing a new fea­ture. You should be able to look at a prob­lem from the user's per­spect­ive and dis­cuss abstract con­cepts with fel­low developers. We expect each of our developers to do archi­tec­ture, design, imple­ment­a­tion, cus­tomer feed­back and bug fix­ing, rather than split­ting these activ­it­ies between sev­eral people. We thus put every­one in con­trol of their own work.

At think-cell, there are no dead­lines, and no sched­uled meet­ings. A fea­ture is ready to be released when you are con­vinced that you have imple­men­ted the best pos­sible solu­tion. Meet­ings take place as needed, with only the people that are actu­ally involved being required to be present. At any time in the pro­cess, ideas, sug­ges­tions and cri­ti­cism from any­body in the hier­archy is wel­come and is ser­i­ously con­sidered. Your ideas are wel­come, even if they mean that we have to change a lot of code to make things bet­ter.

We have pub­lished sev­eral sci­entific art­icles in the areas of Arti­fi­cial Intel­li­gence and Com­puter Graph­ics and we will encour­age you to do the same. We spon­sor vis­its to con­fer­ences and have close rela­tion­ships with uni­versit­ies and research insti­tutes in the U.S. and Ger­many.

think-cell encour­ages a healthy work-life bal­ance. We do not work at night or on week­ends.

We pay very com­pet­it­ive salar­ies and offer our developers EUR 130,000 annu­ally fol­low­ing one year of employ­ment. If neces­sary, we will go out of our way to help you relo­cate to Ber­lin, and will do what we can to help you acquire a work per­mit. While you should be able to com­mu­nic­ate effect­ively in Eng­lish, know­ing Ger­man is not required. Ger­man lan­guage courses can be arranged, if desired.

Do you believe in beauty when it comes to pro­gram­ming? Do you have a vivid interest in eleg­ant algorithms? Are you flu­ent in C++? If so, we would like to meet you. Here is what we offer in a nut­shell:

• A wide array of extremely chal­len­ging C++ devel­op­ment tasks
• An inter­na­tional team of bril­liant minds
• A work­ing envir­on­ment that makes this team stay and grow
• Enough time to make sure that every detail of your solu­tion is per­fect
• A flat organ­iz­a­tion and plenty of room for your ideas
• No sched­uled meet­ings
• Fam­ily-friendly work­ing hours, no dead­lines, no over­time
• Sup­port for relo­ca­tion
• A com­pet­it­ive salary from the start and a raise to EUR 130,000 annu­ally after only one year

About our soft­ware

Our focus is on busi­ness slides (as opposed to more art­ful applic­a­tions) because they offer great poten­tial for auto­ma­tion of lay­out tasks that are tra­di­tion­ally per­formed by Power­Point users them­selves. Chal­lenges are plenty: from a solid under­stand­ing of what makes a good lay­out and which guidelines are fol­lowed by humans who do manual lay­out, to algorithms that pro­duce an accept­able out­put fast enough for inter­act­ive slide design, to a graph­ical user inter­face that sup­ports our new, ori­ginal approach to slide lay­out in a way that is easy to under­stand yet unob­trus­ive, to solid tech­nical solu­tions for auto­matic bug report­ing and auto­matic updates, to com­pat­ib­il­ity with third-party soft­ware on the com­puters of half a mil­lion users.

Here are some high­lights of what we have done.

Lan­guage

• Everything we do is C++. Even our cus­tomer portal is writ­ten in C++. There is some Assem­bler glue code where it is neces­sary, and our build scripts are writ­ten in Python, but other than that think-cell is all about C++.
• We closely track the latest ver­sions of our com­pilers, Visual C++ and Xcode, so we can always use the latest C++ stand­ard fea­tures as soon as they become avail­able.
• We fund the work­ing group for pro­gram­ming lan­guages of the Ger­man Insti­tute for Stand­ard­iz­a­tion (DIN). Some of our employ­ees are mem­bers of this com­mit­tee and vote in the inter­na­tional stand­ard­iz­a­tion pro­cess of ISO/IEC C++.
• We spon­sor the Stand­ard C++ Found­a­tion help­ing them to pro­mote the under­stand­ing and use of mod­ern Stand­ard C++ on all com­pilers and plat­forms.

Lib­rary

• We use Boost throughout our code, e.g., Boost.Spirit for pars­ing.
• We have our own range lib­rary, in the same spirit as Boost.Range or Eric Niebler’s range-v3, but going fur­ther, for example, by uni­fy­ing internal and external iter­a­tion. We gave a talk about it, and most of the code is pub­lic.
• We develop our own cross-plat­form lib­rary to sup­port Mac and Win­dows with a single code base.
• We have our own ref­er­ence-count­ing and per­sist­ence lib­rar­ies to save and restore whole object trees.
• We have an extens­ive bug report­ing infra­struc­ture. Asser­tions and error checks stay in the release code, and our soft­ware auto­mat­ic­ally reports bugs to our server. The server ana­lyzes the bug, cat­egor­izes it and files it in a data­base that all developers can access. If an update fixes the bug, the user can down­load the update dir­ectly from a bug response web page.

Algorithms

• think-cell was foun­ded on the idea for an algorithm for auto­matic slide lay­out, and we are still on an excit­ing jour­ney towards that ambi­tious vis­ion. You can see our most recent release in action!
• We developed a new algorithm for auto­matic point cloud labeling that allows labels to be posi­tioned away from the actual points.
• We developed a new algorithm for auto­matic column chart labeling.
• We are work­ing with John For­rest – author of the lin­ear solver CLP – to make his sim­plex code faster on our kind of prob­lems.
• We developed many gen­eric data struc­tures that are not in C++ or Boost, for example par­ti­tions.
• Our soft­ware not only pro­duces charts, it is also able read them back from paper. For our chart recog­ni­tion tool, we rely on OpenCV and the Lepton­ica Image Pro­cess­ing Lib­rary.

Reverse Engin­eer­ing

• We do lots of reverse engin­eer­ing with the dis­as­sem­bler IDA from Hex-Rays, in order to achieve things that are not pos­sible via the doc­u­men­ted Microsoft Office API.
• We wrote prob­ably the best func­tion hook­ing engine out there. On each start of our soft­ware, we patch the Microsoft Office execut­ables in memory. Rather than hard-cod­ing patch addresses, we search for small chunks of assembly code to be robust against minor changes in the execut­ables.

Interested?
Please click here to apply.