Ip to Location

import requests
import sys
import re
import socket

'''
Module for getting geoData of a Ip
Adress.
'''


def rightIpPattern(ip):
    '''
    Checks for the right ipv4 pattern.
    '''
    return re.match("^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$",ip)!=None

def hasInternetConnection(host="8.8.8.8", port=53, timeout=3):
    '''
    Checks if it's possible to connect with a google sever.
    '''
    try:
        socket.setdefaulttimeout(timeout)
        socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect((host, port))
        return True
    except Exception as ex:
        print(ex)
        return False

def getData(ip,what='country_name'):
    '''
    Returns the Location datas of the given Ip
    what can be:
    *region_code
    *ip
    *time_zone
    *city
    *country_code
    *region_name
    *country_name
    *metro_code
    *latitude
    *longtitude
    '''
    if(hasInternetConnection() and rightIpPattern(ip)):
        response = requests.get("http://freegeoip.net/json/"+ip)
        json = response.json()
        if(what!="everything"):
            return json[what]
        else:
            return json
    else:
        print("Fail, check Ip adress and you internet connection")

if __name__== "__main__":
    print(getData(sys.argv[1],sys.argv[2]))

Fastest sorting algorithm for integers - radixsort

A programmer has often the problem of fast sorting. Which algorithm he/she should take for that type of data. I will show you simply the fastest algorithm but only for sorting integers. I'm talking about the radixsort. But sth like the fastest algorithm doesn't exist for sorting. Because it's always a question of the data type and pattern wich you wan't to sort. 

The code is written in python, because nearly every programmer understands it ^^ 

def radixsort( aList ):

  RADIX = 10

  maxLength = False

  tmp , placement = -1, 1

  while not maxLength:

    maxLength = True

    # declare and initialize buckets

    buckets = [list() for _ in range( RADIX )]

    # split aList between lists

    for  i in aList:

      tmp = i / placement

      buckets[tmp % RADIX].append( i )

      if maxLength and tmp > 0:

        maxLength = False

    # empty lists into aList array

    a = 0

    for b in range( RADIX ):

      buck = buckets[b]

      for i in buck:

        aList[a] = i

        a += 1

    # move to next digit

    placement *= RADIX

How to control the Mouse in Python

You mayby know some of the anoying pseudo viruses wich launches a ghost - mouse on your pc. So how we can do that under Windows with python.

First you need to install the pywin32 package. You can do this of course easely with pip

pip install pywin32

Import:

import win32api, win32con

Mouve mouse:

win32api.SetCursorPos((x,y))

Click Left:

win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN,x,y,0,0)

Click Right:

win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP,x,y,0,0)

Why you should learn Python 10 - Reasons

• [1] I'ts easy to learn

Python is completely generic and you won't have much blue code because of the intuitive Syntax. You will also have the most needed libs in the standart package dir, like libs for parsing xml or for sending mail via smtp.

• [2] Python is powerfull

With the package ctypes you can do a lot of things that C also can do. The language itself has so much extended standart packages that python can also be a monster tool for programmers.

• [3] You can use it for webdevelopment

Ever heard about Django? No... this is the framework in which youtube whas written. And yes it's a python framework.

• [4] You can use it for any platform

Python is a interpreted language which works similar to java when you compile the scripts. It uses a just in time debugger. But yeah wherever the interpreter works, python works too. Windows, Linux Mac os x, Unix(BSD Like) and also android.

• [5] Python is needed in de economy

The amount of needed python jobs is now bigger than ever.

• [6] It also can understand java, c# and of course c

There are more than one interpreter. You can use Jython that also anderstand java or IronPython which is compatible with the .Net Framework.

• [7] It's a university language

Python is the most used language at universities. So when you learn it you will always find a snippet in python.

• [8] You will always find the right package

Because it's the most used language at universities, there are thousands of packages for python. Do to everything you wan't.

• [9] Blender

Also when you are a 3D Artist python will be usefull for you. As you mayby know, the python interpreter is a part of Blender.

• [10] Python is fast

It is the fastest interpreted language when you use Cython and write like you should.

Debugger for Python

The simplest way to debug a python programm is to use the build in module pdb. It is simple to use:

import pdb
import mymodule
pdb.run('mymodule.test()')

Or: python3 -m pdb myscript.py

for more informations : https://docs.python.org/3/library/pdb.html

Disassembler for Python bytecode

It's possible to disassemble easely python bytecode. With python onboard tools. In this case the module 'dis'.

>>> def marcin(n):
...     print(n)
...
>>> import dis
>>> dis.dis(marcin)
  2           0 LOAD_GLOBAL              0 (print)
              3 LOAD_FAST                0 (n)
              6 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
              9 POP_TOP
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE
>>>

The Top 20 Hidden Features of Python

>Just A summary of the hidden possibilities.

>I will explain them in the following Posts

• Braces

from __future__ import braces

• List slicing

a = [1,2,3,4,5,6]
a[2:4]
[3,4]
a[2:]
[3,4,5,6]
a[:2]
[1,2]
a[::]
[1,2,3,4,5,6]

• For .. else Syntax

for i in sfoo:
    if bar(i):
        #do something
        break
else:
    return -1

• Yield statement

def primes(numb):
     while True:
         if isprime(numb):
              yield numb
         numb+=1

• Multiple assignments

 a, b   = 1, 2
(a, b) = 1, 2
[a, b] = 1, 2

• Argument unpacking

def aMethod(arg1, arg2):
    # Do something

foo = (3, 4)
bar = {'y': 3, 'x': 2}

aMethod(*point_foo)
aMethod(**point_bar)

• Decorators

def print_arguments(function):
     def wrapper(*args, **kwargs):
         print 'Arguments:', args, kwargs
         return function(*args, **kwargs)
     return wrapper


@print_args
    def write(text):
        print text

• 'this' Module

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

• Descriptors

class Property(object):
    def __init__(self, fget):
        self.fget = fget

    def __get__(self, obj, type):
        if obj is None:
            return self
        return self.fget(obj)

class MyClass(object):
    @Property
    def foo(self):
        return "Foo!"

• Docstring Tests

• Elipse slicing Syntax

>>> class C(object):
...  def __getitem__(self, item):
...   return item
... 
>>> C()[1:2, ..., 3]
(slice(1, 2, None), Ellipsis, 3)

• Enumeration

>>> a = ['a', 'b', 'c', 'd', 'e']
>>> for index, item in enumerate(a): print index, item
...
0 a
1 b
2 c
3 d
4 e

• Generator Expressions

>>>x = [n for n in foo if bar(n)]

• In place value swaping

>>>a, b = b, a

• Multi-Line Regex

>>>> pattern = """
... ^                   # beginning of string
... M{0,4}              # thousands - 0 to 4 M's
... (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                     #            or 500-800 (D, followed by 0 to 3 C's)
... (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                     #        or 50-80 (L, followed by 0 to 3 X's)
... (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                     #        or 5-8 (V, followed by 0 to 3 I's)
... $                   # end of string
... """
>>> re.search(pattern, 'M', re.VERBOSE)

• Named string formatting

print "The %(foo)s is %(bar)i." % {'foo': 'answer', 'bar':42}
The answer is 42.

• New Types at runtime

>>> NewType = type("NewType", (object,), {"x": "hello"})
>>> n = NewType()
>>> n.x
"hello"

• try exepet & else

try:
#Something to Try
Except(#Excetion):
#Do something
else:
#Do sth other
finally:
#Do always

• .pth files

https://docs.python.org/2/library/site.html

• with statement

from __future__ import with_statement

with open('foo.txt', 'w') as f:
    f.write('hello!')

Python Hook Keyboard

I wrote once a keylogger in C. Today I want to show you that it's also possible to Hook the Keyboard with python.

All you need is to install the pyHook package and to follow my instructions in the code.

For the package: pip --install pyHook

# author:           Marcin Cherek
# python version:   2.7.11
# Date:             12th of April 2016
# language:         English
# License:          OpenSource

from pyHook import HookManager


def OnKeyboardEvent(event):
    print(event.Ascii)


hm = HookManager()
hm.KeyDown = OnKeyboardEvent
hm.HookKeyboard()

Python access Clipbaord

First of all you need to install the clipboard package.
You can do this with pip.

->pip --install clipboard

I use it with python 3 but it will also work with version 2.

import clipboard #Import the package

To get datas from clipboard simply call:

clipboard.paste()

And to write them to the clipboard call:

clipboard.copy("Your Argument")

Python solve Algorithm

# author:           Marcin Cherek
# python version:   3.4
# Date:             5 of Mai 2016
# language:         English
# Title:            solve Algorithm python implementation
import decimal
import logging

logging.basicConfig()
logger= logging.getLogger(__name__)
logger.setLevel(logging.INFO)

#Prepares the the calculation
#this method splits the Operators
#from the Numbers
def _prepare(calculation):
        for i in ["+","-","*","/"]:
                calculation=calculation.replace(i,";"+i+";")
        return calculation.split(";")

#Replaces the sub calculation
#with the Result of it
def _replaceRes(deb,result,zähler):
        deb[zähler-1]=""
        deb[zähler]=""
        deb[zähler+1]=result
        return deb

#Normal calculation of two
#Numebers and one Operator
def _calc(z1,z2,op):
        if(op=="+"):return z1+z2
        elif(op=="-"):return z1-z2
        elif(op=="*"):return z1*z2
        elif(op=="/"):return z1/z2
        
#Shrinks the Array
#It removes the empty elements
def _popArr(deb):
        p=0
        while p<len(deb):
            if deb[p]=="":
                deb.pop(p)
                continue
            p+=1
        return deb

#Most important method
#It iterates the calculation
#and corrdinates the subcalcs with the
#results of it
def _solve_simple(deb,op):
        result=0;zähler=0
        for i in deb:
            if i==op:
                logger.info(deb)
                result=_calc(decimal.Decimal(deb[zähler-1]),decimal.Decimal(deb[zähler+1]),op)
                _replaceRes(deb,result,zähler)
                result=0
            zähler+=1
        deb = _popArr(deb)
        return deb

#Calls the simple Alg
#First of course */ and after that +-
def solve(calculation):
        calculation = _prepare(calculation)
        for i in ["*","/","+","-"]:
                calculation=_solve_simple(calculation,i)
        return decimal.Decimal(calculation[len(calculation)-1])

Programming Books

https://drive.google.com/open?id=0B18_gfM_Pmu-bEpyVU8wOTVPbjQ

• Clean Code
• code complete 2nd edition
• Effective Java
• HeadFirstDesignPatterns
• Java Performance Tuning
• Java Performance the definitive Guide
• Python High Performance Programming
• Software Architecture Design Pattern
• Working Effectively with Legacy Code

KMP Algorithm in Python

# author:           Marcin Cherek
# python version:   2.7.11
# Date:             2 of Mai 2016
# language:         English
# Title:            KMP Algorithm python implementation

#Build the Prefix table
def lspTable(pattern):
    lsp = [0] * len(pattern)
    lsp[0] = 0
    for i in range(1,len(pattern)):
        j = int(lsp[i-1])
        while(j>0 and pattern[i]!=pattern[j]):
            j=int(lsp[j-1])
        if(pattern[i] == pattern[j]):
            j+=1
        lsp[i]=j
    return lsp

def kpm_search(pattern, text):
    lsp = lspTable(pattern)
    j = 0
    for i in range(0,len(text)):
        while( j>0 and text[i] != pattern[j]):
            j = lsp[j-1]
        if(text[i]==pattern[j]):
            j+=1
            if(j==len(pattern)):
               return i-(j-1) #returns the position
    return -1 #Not found

Quicksort in Python

# author:           Marcin Cherek
# python version:   2.7.11
# Date:             12th of April 2016
# language:         English
# Title:            Quicksort Algorithm python implementation


# divide conquer combine
# First we choose a element to compare (pivot)
# Then we put all smaller elements in a list and
# all bigger elements in a list.
# The elements that equals the pivot goes to the pivotList.
# This method is recursive so we repeat it until they are no
# more smaller or greater elements then the pivot.
# At the end we return te more + pivotList + less.
def quicksort(aList):
    return __quickSort(aList)

def __quickSort(aList):
    less = []
    pivotList =[]
    more =  []
    if(len(aList)>0):
        pivot = aList[0]
        for i in aList:
            if i < pivot:
                less.append(i)
            elif i > pivot:
                more.append(i)
            else:
                pivotList.append(i)
        less = __quickSort(less)
        more = __quickSort(more)
    return more + pivotList + less

Mergesort in Python

# author:           Marcin Cherek
# python version:   2.7.11
# Date:             12th of April 2016
# language:         English
# Title:            Mergesort Algorithm python implementation


# divide conquer combine
# First we split te List and then we sort the parts.
# At the end we combine the parts together to one Solution
# We split until it is not more possible to split. Then we compare
# the splited parts.
# We return all sorted Parts combined in one List
def merge_sort(aList):
    middle = len(aList) /2
    leftPart = aList[:middle]
    rightPart = aList[middle:]
    if(middle >0):
        leftPart = merge_sort(leftPart)
        rightPart = merge_sort(rightPart)
    return list(__merge(leftPart,rightPart))


def __merge(leftPart,rightPart):
    sortedL = []
    left_index, right_index = 0,0
    while left_index < len(leftPart) and right_index <len(rightPart):
        if( leftPart[left_index] >= rightPart[right_index]):
            sortedL.append(leftPart[left_index])
            left_index +=1
        else:
            sortedL.append(rightPart[right_index])
            right_index +=1
    if leftPart:
        sortedL.extend(leftPart[left_index:]) #Extend adds a Lists content
    if rightPart:
        sortedL.extend(rightPart[right_index:])
    return sortedL

Heapsort in Python

# author:           Marcin Cherek
# python version:   2.7.11
# Date:             12th of April 2016
# language:         English
# Title:            Heapsort Algorithm python implementation

def heapsort(aList):
    return __heapsort(aList)

# PUBLIC: HeapSort
# We build a heap with the rules
# To build a heap with start a the index of the leastparent
# and iterate to the root Element index of 0. step -1
# In the Second step we flat the Heap to an Array. We start at the
# last nodes Index and and Iterate to zero with step -1.
# In each repeat we swap the root Element with the last Element and
# rebuild our Heap with the rules. This leads to an shrinking Heap.
# The last repeat is when we have a Heap with only 2 Nodes.
def __heapsort(aList):
    # List to Heap
    length = len(aList) - 1
    #We start at the index with the least parent because our down method need childnodes.
    for i in range(abs(length / 2), -1, -1):
        __down(aList, i, length)
    # Heap to List
    for i in range(length, 0, -1):
        #swaps the last element with the rootElement
        __swap(aList, 0, i)
        #restore Heap rules for our smaller getting heap
        __down(aList, 0, i - 1)
    return aList


# PRIVATE: Down
# First we calculate the Children. Left = 2n and Right = 2n+1
# Then we look if the children exists and if they are bigger than
# the parent we swap the elements.
def __down(aList, current, heapSize):
    leftC = 2 * current
    rightC = leftC + 1
    if (leftC <= heapSize and rightC > heapSize):
        #Just one Child on the left site
        if (aList[leftC] < aList[current]):
            __swap(aList, leftC, current)
    else:
        if (rightC <= heapSize):
            #There are two children and it's possible that they are also
            #Parent's
            child = 0
            if (aList[leftC] < aList[rightC]):
                child = leftC
            else:
                child = rightC
            if (aList[child] < aList[current]):
                __swap(aList, current, child)
                __down(aList, child, heapSize)

#PRIVATE: SWAP
# Swap means to exchange a node with his child
# idx_one and idx_two are the indexes
def __swap(aList, idx_one, idx_two):
    #logger.info(("SWAP:", aList[idx_one], aList[idx_two]))
    tmp = aList[idx_one]
    aList[idx_one] = aList[idx_two]
    aList[idx_two] = tmp


if __name__ == "__main__":
    print("RESULT:"+str(heapsort([2, 3, 21, 56, 53, 2, 1, 6, 2, 3, 2, 4, 5, 6, 5, 5, 3, 3, 4, 100])))

CSS Trick - Alles Resizable

CSS Trick - Alles Resizable

Die Textfields kann man im Html standartmässig vergrössern oder verkleinern. Aber was ist mit anderen Elementen wie Divs oder iFrames oder Videos?

Dazu genügt es lediglich die property resize hinzuzufügen.

div{

    resize:both;

}

Daneben gibt es noch zwei weitere Möglichkeiten.

resize: vertical;

resize: horizontal;

Analoge Uhr in Java

Analoge Uhr in Java

Wie programmiert man eigentlich eine analoge Uhr?

Ist eigentlich nicht so schwierig, jedoch braucht man dazu ein bisschen Trigonometrie und ein Verständnis von Thread. Das ergebnis dieses kleinen Tutorials sieht folgendermassen aus;

Wir werden dazu keine Engine,Library oder so was in der art verwenden. Wir überschreiben lediglich die Paint methode des Frames und zeichnen ganz normale Java Lines mit dem Graphic object. Dazu habe ich ein Modell erstellt mit dem Namen Clock, dieses gibt uns pro Sekunde die verschiedenen Coordinaten zum zeichnen, welche es berechnet hat.

Man muss also eine Formel haben die von Sekunden, Minuten und Stunden auf die Coordinaten der Zeiger kommt. Diese sieht wie folgt aus:

    private void calculateCorrs(){
        this.Sec = new Date().getSeconds();
        this.Minute = new Date().getMinutes();
        this.Hour = new Date().getHours();
        int xsecond = (int) (Math.cos(Sec * 3.14f / 30 - 3.14f / 2) * 120 + ORIGIN.x); 
        int ysecond = (int) (Math.sin(Sec * 3.14f / 30 - 3.14f / 2) * 120 + ORIGIN.y);
        this.secCorr = new Point(xsecond,ysecond);
        int xminute = (int) (Math.cos(Minute * 3.14f / 30 - 3.14f / 2) * 100 + ORIGIN.x); 
        int yminute = (int) (Math.sin(Minute * 3.14f / 30 - 3.14f / 2) * 100 + ORIGIN.y); 
        int xhour = (int) (Math.cos((Hour * 30 + Minute / 2) * 3.14f / 180 - 3.14f / 2) * 80 + ORIGIN.x); 
        int yhour = (int) (Math.sin((Hour * 30 + Minute / 2) * 3.14f / 180 - 3.14f / 2) * 80 + ORIGIN.y);
        this.minCorr = new Point(xminute,yminute);
        this.hourCorr = new Point(xhour,yhour);
    }

Der Punkt Origin ist der Punkt welche alle drei Zeiger gemeinsam haben. Nähmlich die Mitte unserer Uhr. In diesem Fall hat das Frame eine Grösse von 350 auf 350 und der Origin ist somit 175,175.

Jetzt noch die update und Paint Methode und das ganze sollte ziehmlich klar werden.

Update:

    @Override
    public void update(Observable o, Object arg) {
        zeichne = true;
        Clock c = (Clock)o;
        this.secCorr = c.getSecCorr();
        this.minCorr = c.getMinCorr();
        this.hourCorr = c.getHourCorr();
        this.repaint();
        this.revalidate();
    }

Paint:

@Override
    public void paint(Graphics g) {
        super.paint(g);
        Graphics2D g2 = (Graphics2D) g;
        if(zeichne){
            RenderingHints rh = new RenderingHints(this.renderHints);
            g2.setRenderingHints(rh);
            g2.setColor(Color.BLACK);
            g2.setColor(Color.red);
            g2.drawLine(Center.x, Center.y, secCorr.x, secCorr.y);
            g2.setColor(Color.WHITE);
            g2.drawLine(Center.x, Center.y, minCorr.x,minCorr.y);
            g2.drawLine(Center.x, Center.y, hourCorr.x, hourCorr.y);
            g2.drawLine(175,25,175,40);
            g2.drawLine(175, 335, 175, 350);
            g2.drawLine(0, 175, 15, 175);
            g2.drawLine(335, 175, 350, 175);
            g2.drawString("12",168,55);
            g2.drawString("3", 325,180);
            g2.drawString("6", 172,325);
            g2.drawString("9",20,180);
        }
    }

Die Striche von 6,12,3,9 sind hardcoded. Das ist in unserem Fall nicht problematisch, da das Fenster nicht resizeble ist.

Der weitere Code erklärt sich von selbst, diesen kann man unter meinem Github Profil finden.

Das Repo : https://github.com/marcin96/AnalogClock.git

XML für Anfänger

XML für Anfänger

XML ist eine sehr beliebte Art Daten darzustellen. Es steht für Extensible Markup Language auf Deutsch für erweiterbare Auszeichnungssprache. In diesem Tutorial geht es darum wie man Xml braucht und wie die Konvention dafür aussieht.

Wo wird es gebraucht?

Xml hat sich in den Jahren vor allem im Web bereich durchgesetzt da es in seiner Syntax auch sehr an Html errinert. Wenn man jetzt zum Beispiel einen Blog schreibt, kann man die Daten relativ einfach also in dem Fall die Posts in XML speichern und so damit auch sehr Leserlich strukturieren mit einem Datum und dem Post Inhalt. 

Aufbau

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<personen>
    <person>
        <name>Müller</name>
        <vorname>Hans</vorname>
        <alter>30</alter>
        <Herkunft>Deutschland</Herkunft>
    </person>
</personen>¨

Die erste Zeile ist sehr wichtig, sie teilt dem Pasrser mit dass es sich hier um ein XML Dokument handelt. Oftmals führt ein Fehler in dieser Zeile dazu, das dass Xml Dokument vom Parser nicht verstanden wird und ein Fehler ausgegeben wird.

Dannach kommt der Root Tag, in diesem Fall die Personen, in jedem Xml Dokument gibt es genau einen Root Tag und nicht mehr. So ist die Konvention. Man versteht dadurch schnell was für Daten sich in diesem Dokument befinden. In unserem Fall sind dies Personen.

Und schlussendlich kommen wir noch zu den richtigen Daten. Zu den Personen. Diese sollten im Idealfall genau gleich aufgebaut werden. Wir sehen, jede Person hat einen Name, Vornamen und ein Alter. Dies wird auch so gespeichert.

Man sieht schon die grosse Ähnlichkeit von XML zu HTML, dass heisst auch Menschen die keine Programmierer sind, sonder sich viel mehr mit der strukturierung von einer Website befassen können XML verstehen.

Parsen

Beim Parsen gibt es zwei Möglichkeiten. Also zwei Vorgehensweisen. Das eine ist SAX und das andere DOM. 

Sax

Sax ist die schnellste Variante ein XML Dokument zu parsen, jedoch liegen die Daten, also der Baum nach dem Einlesen nicht mehr im Arbeitsspeicher. Sax betrachted nicht das ganze Dokument sondern nur die benötigten Teile und liefert uns nur die benötigten Daten.

Dom

Dom ist wesentlich langsamer als Sax, jedoch leigt der Tree, also unser Daten Baum dan immer noch im Abreitsspeicher und wir können auf jegliche Knoten zugreifen. Dom betrachted ein XML Dokument immer als ganzes. Dies lohnt sich oft sehr, jedoch muss man immer auf die Grösse unsere XML Files schauen. Da beim Parsen jedesmall der ganze Datenbaum eingelesen wird.

Beispiel

Jetzt noch einmal zu unserem Beispiel von vorhin. Wir schreiben einen Blog und möchten unsere Posts in einem XML File speichern. Unser Dokument würde dann folgender massen aussehen:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Posts>
    <Post>
        <Titel>Erster Post</Titel>
        <Daten> Hall und wilkommen zum ersten Post...</Daten>
        <Author>Python</Author>
        <Datum>1.01.2016</Datum>
    </Post>
    <Post>
        <Titel>Zweiter Post</Titel>
        <Daten> Hall und wilkommen zum zweiten Post...</Daten>
        <Author>Python</Author>
        <Datum>1.04.2016</Datum>
    </Post>
</Posts>

Linux Commands für Anfänger

Linux Commands für Anfänger

Linux ist das beliebteste OS( Operationssystem) wenn man vom Open Source Bereich spricht. Es hat sich in den Jahre sehr stark auch für den normalen Benutzer durchgesetzt und bieted alle Funktionen die auch herkömmliche commerzielle OS bieten.

Ein grosse Vorteil ist die zur verfügung gestellte Shell. Mit dieser kann man ohne viel herum clicken zu müssen vieles auf einen Schlag erledigen. Mann muss nur wissen wie.

Dieses Tutorial ist vor allem für Einsteiger gedach und erläutert die wichtigsten Commands welche man für den Anfang kennen sollte.

• cd /pfad : wechselt den Pfad
• cat [filename] : Zeigt die Innereien eines Files
• chmod [optionen] [filename]: Ändert die File Berechtigungen
• chown [filename] : ändert den Besitzer eines Files
• clear : Löscht den Consolen Inhalt
• cp [source] [destination]: Kopiert Files
• date [options]: Zeigt das Datum und die Zeit an
• df [options]: Zeigt den belegten und freien Speicher
• du [options]: Zeigt welches File wie viel Speicher belegt
• file [options] [filename]: Zeigt was für eine art Daten im File sind.
• find [Pfad] : Such ein File
• grep [options]: Sucht ein File oder Output nach eine bestimmten Muster
• kill [options] : Stopped einen Process
• ln [oprions] [destination] : Erstellt eine Verknüpfung
• locate [filename] : Sucht copien von einem File
• lpr [options] : sendet einen druck Befehl
• ls : Zeigt alle Daten in einem Verzeichniss
• man [command]: Zeigt die Hilfe für einen Befehl an
• mkdir [options]: Erstellt ein nuene Ordner
• mv [options]: Bennent ein File um oder er verschiebt es.
• passwd [name]; ändert das password oder ermöglicht das ändern des Passwords.
• ps [options]: Zeigt die laufenden Processe
• pwd: Zeigt den derzeitigen Pfad.
• rm [options]: Löscht Files und Verzeichnisse
• rmdir [options]: Löscht leere Verzeichnisse.
• ssh [options] : verbinden sich mit einem anderen Computer per ssh.
• su [options]: Wächselt den user.
• tail [options]: zeigt die letzten n Zeilen von einem File.
• tar [options]: entpackt oder packt in ein .tar Archiv
• top : Zeigt die benutzten Ressource
• touch [filename]: erstellt ein leeres File mit dem Namen.
• who [options]: Zeigt wer eingellogt ist.

MVC - Pattern mit Java

Das MVC Pattern #Java

Hinweis: Dieses Tutorial baut auf der Netbeans Entwicklungsumgebung und der Gui Library Swing auf.

MVC, was ist das?

Nun vielleicht zuerst was mvc überhaupt bedeuted. Und zwar Model View Controller. Dies ist ein Muster das verwendet wird um Software zu strukturieren. In den Jahren hat es sich sehr gut durchgesetzt da man somit viel besser mit anderen Programmieren zusammen arbeiten kann. Dieses Muster wie auch viele andere dienen dazu die Software Elemente klar und logisch voneinander zu trennen. Daraus ergeben sich viele Vorteile. Zum einen findet man so viel schneller einen Fehler, zum anderen ist man viel flexibler wenn es Fehler gibt, das heisst, das programm stürtzt nicht einfach ganz ab sondern nur ein teilbereich funktioniert nicht. Wenn man es richtig macht. Und zu guter letzt sorgt es für mehr Transparenz wenn man in einer Gruppe arbeitet.

Wie funktioniert es?

In diesem Abschnitt möchte ich klären für was die einzelnen Bestandteile zuständig sind.

Model:

Im Model befindet sich jegliche Programmlogik, darunter versteht man die verarbeitung von Daten, sei es um Berechnungen anzustellen oder einen Text zu filtern. Wenn man jetzt ein Programm auf mehreren Platformen realieseren möchte, kann man dank diesem Pattern die Logik nur einmal schreiben und sie dann immer wieder verwenden.

View:

Die View ist für jegliche Darstellung der Daten zuständig. Sie verwalted die Gui( Graphische Benutzeroberfläche). In Java gehen darunter jegliche librarys wie swing, awt oder das neuste Kind JavaFx.

Controller:

Der Controller steuert das ganze. Er ist für die Steuerung verantwortlich. Das heisst er nimmt jegliche Benutzereingaben oder mehr abstract gesagt signale entgegen und verarbeited diese. Die werden an das Model übergeben, unsere Datan werden angepasst und die Gui wir upgadated mit den neuen Daten.

Wieso benutzt man es?

Wie schon vorher erwähnt versteht man das MVC pattern als einen Bestandteil der professionellen Softwareentwicklung.

In Verbindung mit Java

Jetzt kommen wir zu unserem Beispiel.

Wir möchten ein Programm realisieren das mit dem MVC pattern arbeited.

Und was soll dieses Porgramm können?

Nun, machen wir es doch so einfach wie möglich um uns auf das Hauptthema zu konzentrieren.

Unser kleines Java-Programm so anhand von einem click Hallo Welt schreiben.

Zuerst aber sollten wir unsere Packages auch dementsprechend strukturieren, das ganze sollte so aussehen:

Gut jetzt fangen wir mit dem simplen Model an. Für diese Applikation werden wir nur eines brauchen.

Nichts weltbewägendes.

Das Model muss aber von Observable erben. Und wie wir sehen gibt es uns den String "Hallo Welt" zurück. Wichtig ist noch das wir bei jeder veränderung der zu anzuzeigenden Daten immer den Observer benachrichtigen müssen. Mit den zwie Zeile, this.setChanged(); und this.notifyObservers();

Jetzt gehen wir rüber zu unserem View. Dort fügen wir ein JLabel ein und bennen es halloText.

Und natürlich auch einen Button, den halloButton.

So sollte es aussehen.

Die Klasse muss so angepasst werden, dass sie Observer implementiert. Dadurch muss sie auch die Methode update überschreiben.

Und natürlich unsere update Methode:

Wir kasten das Observable objekt nach unserem Model und updaten quasi den Text unsere Labels.

Natürlich müssen wir auf die reaktion irgendwie reagiere, Dafür brauchen wir einen Controller.

Jetzt müssen wir das View noch einmal bearbeiten bevor wir alles verknüpfen, wir brauchn dort eine Methode die unseren Controller registriert. Nennen wir sie auch gleich "registerController".

Zu guter letzt müssen wir noch alles in der main Methode verknüpfen und dan ist es schon fertig.

Der Code sieht so aus:

Jetzt funktioniert unsere Applikation.

Clean Code

Clean Code

Clean Code ist the best book when you want to learn code in a clean way, Of course all conventions are shown together with samples. And the humor of the author is also very specific for geeks.

DOWNLOAD LINK:

https://drive.google.com/file/d/0B18_gfM_Pmu-V1p5RDJuNHozT0U/view?usp=sharing

Clean Code (German)

Clean Code

Clean Code ist das Buch wens um schönen Code geht. Besprochen werden alle nötigen Konventionen natürlich anhand von Beispielen. Mir persöhnlich hat dieses Buch sehr geholfen meinen Code schöner und verständlicher zu gestalten.

Download Link:

https://drive.google.com/file/d/0B18_gfM_Pmu-V1p5RDJuNHozT0U/view?usp=sharing

Java Optimierung

In diesem Post stelle ich euch die wichtigsten Techniken zur optimierung von Java Quellcode vor. Natürlich auch unterstzützt durch Beispiele.

Wie es zu diesem Post kam ist eigentlich leicht zu erklären. Niemand schaut mehr auf die Optimierung von Programmen, da wir doch solche Monstermaschienen produzieren können. In jedem alten Programmierbuch fand man zumindest am Schluss eine Rubrick für Optimierung. Heutzutage wird das gar nicht mehr praktieziert.

Es hat aber schon seine Vorteile. Zum einen ist es besser programmiert und zum anderen spart man dadurch viel Geld. Wenn wir uns mal eine Business Applikation vorstellen die viel Daten verarbeiten muss. Wenn Sie plötzlich in der gleichen Zeit doppelt so viel verarbeiten kann, rendiert sie viel mehr.

Jetzt aber zu den Top Ten Tipps:

1. Arbeite immer nur mit den Daten welche du auch im Moment brauchts. Das heisst, dass zum Beispiel Referenz Objekte welche nur die benötigten Attribute haben oft einen klaren Performance Vorteil schaffen können, vor allem wen es um Grosse Datenmenge geht, wie das der Fall bei Datenbanken ist.
2. Vermeide wenn möglich Methodenaufrufe in einer Schleife. Achte immer ob du nur die nötigsten Dinge in einer Schleife erledigs, dieser Programmcode wird X mal ausgeführt. Durch Veränderungen in dieser Materie kann man vieles bewirken.
3. Achte bei Verzweigungen, dass du die wahrscheinlichsten Fälle zuerst behandelst.
4. Eliminiere jegliche Redundanz in deinem Quellcode.
5. Benutze Cache oder das Clonen von Objekten für bessere Performance.
6. Achte immer auf die DatenTypen welche du brauchts. Erföllen Sie genau nur das, was gebaurcht wird. Oder noch vieles mehr. Und fall du mit Arrays arbeiten solltest, ist arraycopy viel schneller als eine selbstprogrammierte Schleife für diesen Zweck.
7. Wenn dies möglich ist solltest du Konstanten verwenden. Dies gilt so auch für guten Code standart.
8. Verwende wenn möglich lieber if -else statt switch -case. Das letztere ist unter Java langsammer.
9. Verwende ArrayList statt Vektor und StringBuffer statt String.
10. Vermeide wenn möglich Rekursionen

Gute Bücher zu diesem Thema:

• Performant Java programmieren von Hendrik Schreiber