Epsilon-Delta

I was wondering today why my homebrew java apps didn't compile, the version range resolution somehow didn't work as expected

Failed to resolve artifact.



Couldn't find a version in [2.0.0.m1, 1.0.2, 1.0.3, 1.0.4, 1.0.5, 1.1.0,

1.1.1, 1.1.2, 1.1.3, 1.1.4, 1.1.5, 1.1.6, 2.0.0-m2, 2.0.0-m3, 2.0.0-m4,

2.0.0-release, 2.0.1, 2.0.2, 2.0.3, 2.0.4, 2.0.5, 2.1.0-m1, 2.1.0-m2,

2.1.0-m3, 2.1.0-release, 2.1.1, 2.1.2, 2.1.3, 2.1.4, 2.2.0-m1, 2.2.0-m2,

2.2.0-m3, 2.2.0-release, 2.2.1, 2.2.2, 2.2.3, 3.0.0-m1, 3.0.0-m2, 3.0.0-m3]

to match range [3.0,)

  org.datanucleus:datanucleus-core:jar:null

Well, shouldn't 3.0.0.-m1 (m2,m3) at least mach 3.0. ? As it turns out, as soon as a version string "violates" the maven2 naming schemes, your whole version string is being interpreted as a qualifier.

This discussion @ stackoverflow demonstrates that problem

Well are version ranges a bad thing? IMHO Version ranges are fine in certain cases, if you require a certain amount of api compatibility for your code to work.

Yesterday I blogged about quicksort that implied folk dance, today I received spam about "Trachtenmode" and Dirndls. This must be the internet era!

That's great, that's exactly what a bald-headed, 100kg computer-infested programmer / nerd would love to do!! Let's go


(click for the complete image from the "html newsletter")

I can see a Perl script here...
I can even smell it
At least a Perl script is reading my blog.

That's UBER-fantastic.



After watching this you can probably easily figure out a way to parallelize this algo

And now you can measure quick sort in calories burnt.

Remember O(n log n) ? You better do...

 Yeah, today I passed the Qt Essentials Exam, and therefore I am a Nokia Certified Qt Developer now.

Please, stay seated !

I really like Alan Watt's book as a general introduction to the topic, anyway there's a huge error on page 7 (3rd edition) , where the basics of Matrix operations are described. Rotation around an arbitrary point in 2D space is done by translating to the origin (T1) , rotating (R) , then translating back (T2) . Since Watts' book uses column vectors (like GL, as opposed to row vectors / DirectX) thats basically T2 R T1 x for a given vector x. Well, Alan Watts' book shows T1 R T2 x

Still a good book.

I am programming parallel sorting algorithms with MPI / C++ on computer clusters right now, and therefore had to implement qsort in a serial fashion (before creating a parallelized version of it) ..

For arrays of integers, the following "pedestrian" C-code implementation beats the builtin quicksort implementation (defined by ISO) on Linux by being 58% percent faster...

inline void swap(int* p1, int* p2) {

    int tmp = *p1;

    *p1 = *p2;

    *p2 = tmp;

}



inline int divide(int* start, int* end, int pivotIndex) {

    int len = end - start + 1;

    int pivot = start[pivotIndex];

    int storeIndex = 0;



    swap(&start[pivotIndex], &start[len-1]);

    for (int i=0; i < len-1; i++) {

        if (start[i] < pivot) {

            swap(&start[i], &start[storeIndex++]);            

        }

    }

    swap(&start[storeIndex], &start[len-1]);



    return storeIndex;

}



inline void mysort(int* start, int* end) {

    int len = end - start + 1;

    if (start >= end || len == 1) {

        return;

    }

    int pivotIndex = rand() % len;

    int newPivotIndex = divide(start, end, pivotIndex);

    mysort(&start[0], &start[newPivotIndex-1]);

    mysort(&start[newPivotIndex+1], end);

}

These are my results for a randomized array of integers...

Sorting 57 MB

My sort: 3694 msec

Quicksort: 5861 msec



Intel(R) Pentium(R) D CPU 3.00GHz (Presler)

2GB RAM

Linux 2.6.32-5-amd64 x86_64 GNU/Linux

g++ (Debian 4.4.5-8) 4.4.5

glibc 2.11.2

Not bad.. The reason? Inlining. . Rather missing inlining. For glibc qsort, the comparison method (which I provide) can't be inlined, since the code for qsort has already been generated, it's in glibc. Again, in my implementation the comparison is within the existing divide method.

The complete file, for those interested: main_sort.cpp. For large arrays, be sure to set the maximum stacksize accordingly.

Again, on Windows the qsort provided by VS 2010 is twice as fast as my implementation!

PS: I know, this ain't real "beating", because it doesn't improve the algorithmic complexity

Hi Folks,

Problem
I downladed the latest NVIDIA drivers for my 8800GT. Everything worked fine until I tried to start Borderlands.

I was pretty busy lately - as always - and wanted to relax for an hour or so.

It hung at the splash screen. Damn. It really hung. CPU 0%, NO IO being done. Nothing.

Argh...

I attached my VS.NET 2010 debugger to that process and took a glimpse.




Hmm.. nothing interesting. WaitForSingleObject means basically waiting for ownership of a Mutex or Win32 Kernel Event. A deadlock? Seems like some optimizations in the latest NVIDIA driver exposed a vulnerability of the game code towards deadlocks. It's probably not NVIDIAs fault ..

Anyway, the other threads didn't provide any useful info. Actually, I had no time. I just wanted to take one or two hours off and relax now.. So i decided to work-around it.

This is my quick hack
I decided to forcibly serialize / "single-thread" the execution..

I simply started Borderlands from Steam, as soon as the process started to appear in the process manager, I changed the affinity for that process to one physical CPU This won't make the execution single-threaded, but would reduce the probability of the dead lock because there is no hardware parallelism anymore wrt CPU cores.



You have to be quick If the splash screen appears, it's too late ... .



... Then the game started normally, it passed the splash screen ... I immediately activated all cores again.

If you have a SSD this may be difficult :-/ Anyway I could continue this way.

And off I went blasting off some psychos

REMEMBER: If it took more than one shot, you weren't using a Jakobs

I took a quick glance at the 2009 sortbenchmark.org results, where Hadoop reached the first place.

The benchmark category is called GraySort
Metric: Sort rate (TBs / minute) achieved while sorting a very large amount of data (currently 100 TB minimum).

This is how it looked like


73 times more nodes!?
(the raw cpu power of the nodes are roughly comparable - both Dual Quadcore)

Even though the benchmarks themselves aren't 100% identical (but triton was also sorting 100 terabytes), I think its remarkable..

Sometimes you just have to look at the numbers.

A lot of people like to point out that code efficiency for webapps isn't relevant nowadays, code can be slow, even glacially slow given the fact that the webapp mostly waits for the database anyway.

This, quite frankly, is wrong almost all of the time.

Let's take a look at writes (since the reading problem can be solved by some kind of caching strategy - once you have almost everything cached you are measuring Dictionary/Map performance).

I invite you to turn on statement logging on your database and capture the SQL DML that's being emitted by your favourite webapp framework for a specific write use case (including the transaction boundaries). Turn off your logging again for max. performance. Normally your web framework will be capable of handling 5-20 non-cacheable user requests/sec that result in direct write requests to the database (measure with httperf or whatever). Now shut down your webapp, and run that queries directly against your database, using the correct transaction boundary. Then run queries in parallel. Get some solid numbers.

You may discover that the transaction and its queries complete in a few msecs, and you get a lot more requests/s to the DB right away. From a plain DB perspective on a developer machine. Now who's bottlenecking? Certainly not your DB.

If your queries really run slow, the first step is to ensure correct DB design and DB configuration. Your db design must be sane (2NF/3NF or BCNF) and indices must have been set correctly. Technical issues like full table locks with MyISAM matter. String operators and functions in general, LIKE queries etc. Yes, of course you will have to be able to optimize or circumvent really "hard" queries.. At the end of the day, with sane database design, you can get really decent performance.. on a totally normal, average box. And the database will prevail. A whole lot more is going to die before that CUSTOMERS table won't exist any more.

Of course, Disc IO is the upper limit for DB IO (if the db really fsyncs on every transaction), but even with std 7200RPM Discs on developer machines you can get fast performance with correct db design.

But don't tell me your webapp is only capable of handling just a few req/s per second for your average webapp because of your database.

It's highly probable that everything else is preventing you from achieving higher throughput...

...Your ORM that thinks its an object runtime
...Your favourite programming language
...Your beloved ultimate framework,
...Your own application code
...Missing caching strategy
...And a whole lot more

PS
I am not talking about ultra-high-traffic sites here, like facebook. I am talking about normal webapps with moderate traffic.. It makes me wonder why everybody tries to solve the problems facebook has to solve (millions of users and gazillions of internet traffic) ...

PPS
If in doubt, measure.

As found on the OpenMPI FAQ Page : OpenMPI Faq



Cheers

Hi Folks,

I wanted to do some mindmapping on Windows and liked vym. No official Windows port available. The one I found wasn't able to save my file to the Desktop (I didn't read the known issues - no spaces in path allowed), so I had to use Freemind which is just the typical huge, clunky java "App". I bit the bullet and created 2 diagrams (needed for my parallel programming course at fernuni hagen), anyway after studying I went to work, came back home in the evening and just downloaded the sources and built a version with the current Qt SDK. Some minor problems with a QDBus dependency, fixing stuff while compiling. 10 Minutes.

Then I converted my 2 diagrams and erased Freemind from my HD.

Problem. Solved.

A page with further info and a download can be found here (including GPL sourcecode):
Vym (View your mind) for Windows

Have fun!

Hi,

If you just want to get started quickly with google's own c++ mocking framework (which also bundles their testing framework), you might find my cmake macro handy (That is, if you are using cmake ). You can download my macro from here:FindGoogleMockMinimal.cmake

It's for those cases where you are just banging out an test executable and need the gmock-all.cc and gtest-all.cc files in order to make your code run. Therefore you just need an unpacked google-mock sourcecode package, and don't have to build it..

Step 1: CMakeLists.txt changes

Here's how your CMakeLists.txt would look like:

find_package(GoogleMockMinimal REQUIRED)

INCLUDE_DIRECTORIES(${GMOCKMINIMAL_INCLUDE_DIRS})



FILE(GLOB MY_TEST_SRCS .cpp .h)



ADD_EXECUTABLE(MyTest

     ${GMOCKMINIMAL_SRC}

     ${MY_TEST_SRCS}

)

As you can see, you only need ${GMOCKMINIMAL_INCLUDE_DIRS} and ${GMOCKMINIMAL_SRC}.

In order to use the CMake Finder Macro you have to first "register" it in your CMake file - f.e. if you put it into a subfolder cmake/Modules, this is the snippet:

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")

Step 2: Configuring cmake

At configuration time, set the variable ${GMOCK_SOURCE_ROOT} to point to the gmock sourcecode.

cmake -DGMOCK_SOURCE_ROOT=/wherever/it/is

That's it

Here is the CMake Macro File in all its glory

#

#

# Locate and configure the Google Mock (and bundled Google Test) libraries for minimal setup

# Tested with google mock version: 1.6, Win32 (VC.NET 2003) & Linux (gcc 4.x.x)

#

# Defines the following variables:

#

#   GMOCKMINIMAL_FOUND - Found the Google Mock libraries

#   GMOCKMINIMAL_INCLUDE_DIRS - The directories needed for include paths

#   GMOCKMINIMAL_SRC - The minimal set off .cc files to use with an executable (mock+test)

#

# Copyright 2011 Amanjit Gill (amanjit.gill@gmx.de)

# Based on a CMake macro from Chandler Carruth

#

#	Licensed under the Apache License, Version 2.0 (the "License"); you may not

#	use this file except in compliance with the License.  You may obtain a copy

#	of the License at

#

#		http://www.apache.org/licenses/LICENSE-2.0

#

#	Unless required by applicable law or agreed to in writing, software

#	distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

#	WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the

#	License for the specific language governing permissions and limitations

#	under the License.

#

#



if(GMOCKMINIMAL_INCLUDE_DIRS)

  set(GMOCKMINIMAL_FOUND true)



else(GMOCKMINIMAL_INCLUDE_DIRS)

  set(GMOCK_SOURCE_ROOT "" CACHE PATH "Source folder for Google Mock")



  if(GMOCK_SOURCE_ROOT)

    find_path(_GMOCKMINIMAL_INCLUDE_DIR gmock/gmock.h

      PATHS "${GMOCK_SOURCE_ROOT}/include"

      PATH_SUFFIXES ""

      NO_DEFAULT_PATH)



    find_path(_GTESTMINIMAL_INCLUDE_DIR gtest/gtest.h

      PATHS "${GMOCK_SOURCE_ROOT}/gtest/include"

      PATH_SUFFIXES ""

      NO_DEFAULT_PATH)



    find_file(_GMOCKMINIMAL_SRC /src/gmock-all.cc

      PATHS "${GMOCK_SOURCE_ROOT}"

      PATH_SUFFIXES ""

      NO_DEFAULT_PATH)



    find_file(_GTESTMINIMAL_SRC /gtest/src/gtest-all.cc

      PATHS "${GMOCK_SOURCE_ROOT}"

      PATH_SUFFIXES ""

      NO_DEFAULT_PATH)



  else(GMOCK_SOURCE_ROOT)

    find_path(_GMOCKMINIMAL_INCLUDE_DIR gmock/gmock.h

      PATH_SUFFIXES "")

    find_path(_GTESTMINIMAL_INCLUDE_DIR gtest/include/gtest.h

      PATH_SUFFIXES "")

    find_path(_GMOCKMINIMAL_SRC src/gmock-all.cc

      PATH_SUFFIXES "")

    find_path(_GTESTMINIMAL_SRC gtest/src/gtest-all.cc

      PATH_SUFFIXES "")



  endif(GMOCK_SOURCE_ROOT)



  if(_GMOCKMINIMAL_INCLUDE_DIR)

    set(GMOCKMINIMAL_FOUND true)

    set(GMOCKMINIMAL_INCLUDE_DIRS ${_GMOCKMINIMAL_INCLUDE_DIR} ${_GTESTMINIMAL_INCLUDE_DIR} 

      ${GMOCK_SOURCE_ROOT} ${GMOCK_SOURCE_ROOT}/gtest CACHE PATH

      "Include directories for Google Mock library")

    set(GMOCKMINIMAL_SRC ${_GMOCKMINIMAL_SRC} ${_GTESTMINIMAL_SRC} CACHE PATH 

      "Source paths for Google Mock / Google Test combined cpp file (gmock-all.cc and gtest-all.cc)")

    mark_as_advanced(GMOCKMINIMAL_INCLUDE_DIRS)

    mark_as_advanced(GMOCKMINIMAL_SRC)

    if(NOT GoogleMockMinimal_FIND_QUIETLY)

      message(STATUS "Found minimal setup for the Google Mock library: ${GMOCK_SOURCE_ROOT}")

    endif(NOT GoogleMockMinimal_FIND_QUIETLY)



  else(_GMOCKMINIMAL_INCLUDE_DIR)

    if(GoogleMockMinimal_FIND_REQUIRED)

      message(FATAL_ERROR "Could not find the Google Mock library")

    endif(GoogleMockMinimal_FIND_REQUIRED)

  endif(_GMOCKMINIMAL_INCLUDE_DIR)



endif(GMOCKMINIMAL_INCLUDE_DIRS) 

Once again, the download link: FindGoogleMockMinimal.cmake

Have fun

Relation Types capture relations between two or more Entities.

Reminds me of that VISIO 200x WTF: The shadow property of every shape in a drawing was actually a property of the page setup, and couldn't be changed for an individual object

THAT'S SO ENTERPRISEY

And people actually complain about creating diagrams with MS Office tools.

Hint: At least it works.

Hint to myself: Visio is actually a part of the MS Office suite

As a Software Dev, during the lifetime of a software project, you probably are writing some kind of docs, brainstorming etc, documentation...

At least you should

Since you are a developer, this (probably) is you wishlist

• everything should be checked into your VCS
• hence it shouldn't be a blob - a binary
• docs should be editable on multiple platforms
• by multiple users
• hence you would like to diff things
• open file formats.
• be able to use your beloved editor
• still all features of a word processor

Ideally - text files. Actually it's pretty funny. Developers stick to text files while all kind of interactive apps exist for the rest of the world. But we choose independence. Still we would like to have cross references, images, etc..

Zim hits this sweet spot. You get an explorer-like desktop user interface to a wiki that is saved as plain text files on your harddrive. You get the wysiwyg thing, wiki cross-references and export functionality.

Now there's no reason not to document features, requirements and code

Actually I am a huge OneNote Fan and User. I guess that's why I like Zim, too...

I am right now studying linear and non-linear optimizations while attending a mandatory mathematics course @ Universität in Hagen. Functions from R^2 -> R can be easily visualized - guess that qualifies for a textbook example ... Consider this optimization problem





The visualization contained in the course textbook looks like this





This is a contour plot - but I don't think its helpful to just present this graph. The normal plot and the contour graph made things a lot easier for me - I fired up the XMaxima CAS, and plotted this graph and it's contour graph






From an educational and visual point of view I think it's obvious which one is easier to grasp for a student ...