28.02.2013

Linux

Struct file_operations

Struct file – represents open file

filp – file pointer f_mode (read , write )  , f_op  , f_pos , private data , inode

inode – represent file

i_rdev actual device number

i_cdev char device info  

process descriptor

struct tast_struct

process state –> task_running , task_interruptible , task_stopped (after signal )  task_traced (debug mode )

exit_state –> exit_zombie , exit_dead

multiplexed IO

select method waits for files to become ready (can be used to sleep )

gnome

gdk+

g_signal_connect

gdk_window_new

gdk_main

Tomcat

Tomcat class loaders

loads classes in the following hierarchy:

Bootstrap –> $java_home/jre/lib/ext + jvm

System –> $catalina_home base jars

common

Webappx –> class loaders for each web app

JAVA

getClassLoader –> every class after compilation has a property class that can retrieve the class loader

the class loader can load classes from the net or from byte array

Embedded Linux

 

LXR : Linux cross reference utility

Block drivers request struct blk_fs_request

physical memory

pg_data_t

config_page_data

The physical memory is divides to 3 parts :

Zone_DMA  , Zone_normal < 1G , Zone_Hight

http://www.makelinux.net/books/lkd2/ch11lev1sec2

mmu – memory managements unit

Kernel logic address –> 840Mb ממופה למקום קבוע

Kernel virtual address , user space , zero pages –> random opportunities

Spring

autowire = “constractor”

annotations of bean members :

@Required
@autowired –> the required can be cancel on the annotation

@qualifier

BeanInitializeException

Bash

$./myscript 3>&1 1&sdtout.log 2> &3 | tee –a stderr.log

ps –ax | tee processes.txt | more

OSGI

BundleActivator interface

context.RegisterService

Context.getServiceReferances

DDD

Refactoring

WIF

wif claims programming model

ClaimIdentity implements IIdentity

ClaimsPrincipal implements IIPrincipal

claim class

asp .net

OAuthWebSecurity

Spring integration

Gatway – sync , async

Allow to create a gateway to the channels in order to send messages

Service_Interafce = “<the interface >”

Service_Activator

maven

maven eclipse pluging

QT

require “qt”

class QTapp < qt::widget

def initialize

super

hotlable = qt::Label.new .self

 

MDX

The with statement allow to add calculation to the facts table

27.02.2013

Sql server

@@Identity , Scope_identity

Ident_current

Sequence –

האפשרות לקבוע את הסדר של ההכנסה באמצעות שימוש ב over כאשר עושים insert into and select

php

parent::_construct

 

python

super (myClass ,self )._init_()

camel

Camel message model

message – unique identifier , headers attachments

body –> java.lang.object

Exchange   : envelop of the message that send over the channels

Routing engine , routes , dsl,  processor

neo4j

Cypher , gremlin neo4 traversal api

mysql

Load Data

on duplicate –> belong to create item

create table space

Redis

$redis = Redis.new (:timeout = 0 )

$redis.subscribe ( channels names ) do | on |

on.messsage do |chanell ,msg |

.

.

.

end

end

implements pub sub

Hadoop

class reducer

SetSortComperatorClass

SetGroupingComperatorClass

MongoDB

locks on the DB

read , write locks writes lock has a priory over read lock

Sharding – every instance has its on lock

CXF

cxf frontends – jax ws

contract or code first development

service endpoint interface sei

@Webservice jaxax.jws.webservice –> ServiceName , port name

@SoapBinding

@WebMethod

c++

move assignable

is_move_assignable

struct b

{

B(B&&) = delete ;

}

Regex

.

.{1,3}

http://Regexpal.com

? zero or one

Hibernate

@ManyToMany

@JoinTable

מוגדר ביחד עם ה Set

RabitMQ

ack messgae , reject a message

UPNP

When device become enable it send a multicast SSDP notify message

Control point – search for devices by sending SSDP M_SEARCH multicast message

Device description –> device data , services list

upnp control –> post http soap formating message

upnp eventing

upnp presentation –> http get page

 

 

 

 

אז מה היה לנו היום

עמית לעבודה ביקש ממני שאכתוב באיזה טכנולוגיות התעסקתי בכל יום אני לא בטוח שאצליח להתמיד בכך מעבר להיום אבל אנסה .

SQL SERVER

דבר ראשון היום עבדתי על פרויקט ב .net עם דרישה ל db די גדול (לא ענק אבל די גדול ) וזמני תגובה טובים .מכיוון שאין לנו נתונים גם לא מזויפים לdb בסדר גודל שהולך להיות ב production אנו משתמשים בטכניקה של update statistics על מנת לדמות לsql server את הסטאיסטיקטת שהולכות להיות לו ב production לצרכי בחינת ה execution plans השונים (בעיקר העיקריים שלנו)

UPDATE STATISTICS myTable (PK_myTable) WITH ROWCOUNT = 100000

את השיטה למדתי מבלוג post מצויין:

http://blogs.microsoft.co.il/blogs/nayatech/archive/2012/03/07/update-statistics.aspx

UPNP

באחד הפרויקטים שלנו אנו מריצים כעת poc שמשתמש ב פרוטוקול של upnp לטובת discovery של devices ברשת.הDevices הינם מבוססי linux embedded . ה poc נכתב כולו ב windows 7 הן ה server שימשיך להיות מפותח בwindows 7 והן ה devices שכרגע לצורכי ה poc בלבד נכתבו ב windows 7.

Domain driver design

פרויקט בשלבי התכנון נשאלתי לגבי מימוש של יחידה שתפקידה לשלוח איימילים איך זה מבוטא כ service ב ddd ואיך services אחרים צריכים לפנות אליו .

 

Android

נגעתי בבאג שטחן לנו את הסוללה בפרויקט שמבוסס על byod  בקטע קוד שתפקידו להפעיל network location provider לעדכון מיקום בסביבה של מבנה עם חללים פנימים .

 

Neo4J

פרויקט שנמצא בשלבי ארכיטקטורה מתקדמים כאשר למרות שיש בו צורך ב relational db עדיין אנו משלבים Neo4j ליצוג קשרים ב graph של ישויות. הפרויקט נכתב ב python

Cxf

הדגמתי שימוש ב Cxf ליצירת web service דגש על השילוב של Cxf ו Spring היום זה היה החלק הפשוט אך בהמשך אנו נצטרך לנגוע עמוק ב cxf עקב דרישות שאפרט בהמשך.

Wcf

עזרתי לפתור באג שנוגע ל דריסת נתונים ב server עקב זה שה methods סומנו כ OneWay ונקראו אסינכרונית על ידי ה service .

JNDI

עזרתי לתכנת לכתוב custom resource factory של jndi דבר די פשוט עם המימוש של

ObjectFactory 

 

Rubi

Ruby הינה שפת תיכנות די חדשה אצלנו עזרתי לתכנת להבין את הנושא של iterators ו block code

Linux

במערכת embedded שמפתחים אצלנו כרגע אנו כותבים block driver ל storage יחודי .

Developing a Web Service using apache CXF

apache cxf  מאפשרות לנו בקלות להגדיר web service באמצעות pojo objects

שלב א הגדרת ה Contract

package learn.cfx.ws    ;
import javax.jws.WebService;
@WebService
public interface IUserDataRepository {
      @WebMethod
      void SetUserData ( UserData pUserData);

      @WebMethod
      UserData GetUserDataByID ( int  pID);
}

שימוש ב @WebService על מנת לציין שה interface  מגדיר service endpoint interface  או contract  בלשון wcf

הattribute  של @WebMethod מאפשר לעשות קסטומיזציה על הגדרת ה methods  של ה interface  כגון שם הmethod  ב wsdl וכד

שלב ב הגדרת ה payload  של UserData

package learn.cfx.ws;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "UserData")
public class UserData {
 private String mName;
 private String mID;

 public UserData() {
 }

 public int getID() {
   return mID;
 }

 public void setID(int pID) {
   this.mID = pID;
 }

 public int getName() {
 return mName;
}

public void setID(int pName {
 this.mName = pName;
 }
}    

שימוש בספריית Java Architecture for XML Binding

(JAXB)

האנוטציה @XmlRootElement מגדירה את ה root  של ה xml  המתאר את userdata  

ניתן לבצע קסטומיזציה של כל אחד מה properties  באמצעות @XmlElement

שלב ג הגדרת  ה Service

package learn.cfx.ws    ;
import javax.jws.WebService;

@WebService
public class UserDataRepositoryImpl implements IUserDataRepository {

public UserDataRepositoryImpl(){
}
        
public void SetUserData ( UserData pUserData){
    //do nothing 
}


@WebMethod
UserData GetUserDataByID ( int  pID){
    UserData RetValue = new UserData();
    RetValue.setName ("Shaaf Peer");
    RetValue.setID (2);
    return RetValue;

}
}

שלב ד הגדרת ה Binding  באמצעות spring

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">
<import resource="classpath:META-INF/cxf/cxf.xml" />
<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
<import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
<jaxws:endpoint
id="UserDataRepository"
implementor="learn.cfx.ws.UserDataRepositoryImpl"
address="/UserDataRepository" />
</beans>

אני בדרך כלל חובב maven  על פני ant  לכן יש להוריד את ה pom  המתאים מהמרשתת על מנת לקבל pom עם מספר הגירסה המעודכן ביותר של cxf

אך בלילה בלילה חולם ב++c ית

השבוע דיברתי עם גל הילד שלי על זה שהוא חייב בתיכון לבחור שפה שלישית אידיש אל אף עתיקותה יש דברים שאפשריים רק באידיש בעיקר הומור זה החוזק והבלעדיות של השפה וכמה שיתפחו  או ישקיעו בעברית או כל שפה אחרת זה לעולם לא יהיה זה .

כיום מיקרוסופט נותנת boost ל c++  שפה שהיקף השימוש בה ירד עם השנים לטובת שפות דינמיות יותר ויותר .עדיין משחקים ותוכנת רציניות נכתבו ב c++ מיקרוסופט מעולם לא נטשה את ה c++ וחלק ניכר מה products  שלה נשאר native בשפת c++  .אבל ציבור המפתחים שבשנים 1992 ראה ב c++  את העתיד עם היחלשותן של cobol   fortran  ו pascal  די נטש אותה עם השניים לjava , c# ואח"כ לשפות יותר דינמיות של python , ruby , php וכד.

C++  עם השנים הביאה רעננות ויכולות חדשות לשפה בהרבה מאוד תחומים .

תחביר ל lambda expression   וanonymous functions  .

ספריות סטנדרטיות לטיפול ב strings (שהיו קימות כבר ממזמן אבל התפתחו להם )

ספריית <thread>  שעוטפת את השימוש ב threads  

עטיפה ל Direct compute  בספריית amp  המאפשרת להאיץ קוד על ה GPU

הגדרת function pointers  יותר קלה .

Tuples

ועוד

בתור מפתח קשיש אני מברך על שובו של ה c++ ,בימים אילו שnode.js מביאה את ה javascript לשרת יש בc++  כוח ויכולות בהן יש לה יתרונות על שפות אחרות בעיקר במערכות embed  , Drivers  עבודה עם opengl  ו directx  .

BeagleBoard

BeagleBoard הינו כרטיס של embeded computer המשמש אותנו לצרכי ביצוע poc מהירים .האח הבוגר החכם והחזק של beaglebone השכיח אצל חובבנים בתחום .


אנו משתמשים בפלטפורמה linuxית ממספר סיבות העיקריות בהן הינה שבניגוד ל windows embeded  הכל חינם.וגם עצם זה שזה קוד פתוח מאפשר לנו לגשת למחוזות שהיו סגורים בפנינו ב windows embeded.
מבחינה ארכיטקטונית הפתרונות שלנו בד”כ נראים כך :

המערכת מורכבת מ
1.כרטיס beagleboard שהוא הembeded computer שמריץ את כל הלוגיקה של הפעלת ה device
2.מDriver שלנו שעיקרו המרות מתחים בין ה Beagleboard ל Device המופעל ,לפעמים הוא גם מכיל לוגיקות real time שקשה או מיותר להעמיס את הbeagleboard בהם .החיבור הינו באמצעות קווי io מה beagleboard בד”כ למרות שלפעמים החיבור מתבצע באמצעות יציאות אחרות .
Device .3
4.מחשב שתפקידו שו”בי בעיקר כגון תיכנון משימה ב offline בצגת גרפיקה מאוד מורכבת וכד ממשק משתמש חכם הקישור ל beagleboard  מתבצע באמצעות lan למעט מקרה אחד בה החיבור היה באמצעות usb המחשב לא תמיד מחובר למערכת.המחשב לא מריץ בהכרך linux בזמן העבודה למרות שבפיתוח תמיד אנו עובדים במערכת linux ית  לצרכי פיתוח הקוד .

תצורה נוספת שלפעמים אנו משתמשים בה הינה :


בה החיבור לתצוגה הינה ישירות מהכרטיס ליציאת S-Video של ה Beaglebourd.קוד התצוגה נכתב ב QT ובד”כ מתקבל באיכות מעולה

mef vs dynamic class loading from configuration

השבוע יצא לי להשתתף ב architecture design review בו הוצג פיתרון לבעיה הבאה:

תיאור הבעיה

מרחב הבעיה הנו מערכת לעיבוד אות וידאו הכתובה ב dot net אשר צריך לממש בה את החיבור למקורות וידיאו שונים .

הארכיטקטורה נדרשת להגדיר את החיבור בין assembly שמכיל אלגוריתם לעיבוד וידיאו ל assembyמתאם למצלמה .כאשר יש דרישה שאהיה decoupling בין שני הassemblies נוכל להחליף את המתאם המצלמה הנוכחי במתאם אחר מבלי לשנות דבר בassembly של עיבוד הוידאו .

ארכיטקטורת הפתרון המוצא

ארכיטקטורת הפתרון שהוצגה התבססה על שימוש ב microsoft mef על מנת לבצע את החיבור בין ה assembles

  [Export(typeof(ICameraControl))]   
  public class CameraTypeBAdapter : ICameraControl   
  { 
         public byte [] GetNextFrame() 
         {
                 return theNextFrame;      
         } 
   }

בצד של ה client

class CameraController
{
    [Import(typeof(ICameraControl))]
    public ICameraControl CameraControl { get; set; }

    public void Init()
    {
        try
        {
            AggregateCatalog aggregatecatalogue = new AggregateCatalog();

            aggregatecatalogue.Catalogs.Add(new DirectoryCatalog(
                AppDomain.CurrentDomain.BaseDirectory));

            CompositionContainer container = new CompositionContainer(
                aggregatecatalogue);
            container.ComposeParts(this);

        }

        catch (CompositionException cex)
        {
            Console.WriteLine(cex.Message);
        }
    }

    public byte[] GetNextFrame()
    {
        return CameraControl.GetNextFrame();
    }
}

נדרש שה server לא יהיה singleton דבר אשר יכול להישלט על ידי attribute של

[PartCreationPolicy (CreationPolicy.NonShared)]

על הclass של ה server.

בחינת ה Domain של הבעיה מראה שכרגע קימות שתי מצלמות שצריך לתמוך בהן לא הוגדר שבעתיד יצטרכו לתמוך במצלמת אחרות וההחלטה לבנות תשתית שתתמוך בתהליך כזה התבשלה אצל המפתחים של הפרויקט האפשרות שבאתר ה production כל מה שיצטרכו לעשות על מנת להחליף סוג מצלמה זה להחליף dll לא היתה חלק מה domain .

לפעמים מפתחים מכניסים תשתיות שאין בהן צורך. הדבר מייקר ומסבך את הפיתרון סתם.

באותה מידה יכלו המפתחים להחליט שהחלפת המצלמה תהייה on the fly .חשוב ב desgins review לרדת לעומקו של מרחב הdomain של הבעיה אותה מנסים לפתור לפני שצוללים לפתרון ברמה טכנולוגית .

ההמלצה שלי

אין כל סיבה כאן לשימוש במיקרוסופט mef אשר תסבך את הארכיטקטורה .

mef לא נותנת כאן ערך מוסף לפתרון אלא רק מגבילה אותו :

1.לא נוכל להפיץ שני adapters במקביל באותו bungle של assemblies .
2.שליטה על תהליך ה יצירה של ה class ים הנו מוגבל ב mef

לפי דעתי שימוש ב קונפיגורציה להצבעה על ה assembly וה type הנה פתרון פשוט וגמיש יותר .
מבחינת ביצועים לא צריכה להתבצע סריקה של כל ה type במערכת על מנת לבצע את הקישור בין ה client והserver
כמו כן מתן אפשרות שליטה למשתמש המערכת לבחור את הקונפיגורציה הרצויה יותר פשוטה .
מפתח המערכת צריך להכניס קוד שקורא מקונפיגורציה את ה assembly וה type וליצור את ה class זה לא קוד מורכב או מסובך .

spring framework לפי דעתי נותנת כלים טובים ופשוטים לפתרונות בעיות אילו
דוגמה בspring לפתרון הבעיה

 <bean id="CameraControl" class="com.zvika.camera.services.CameraControlB">
           
 </bean>

הקוד לטעינת ה bean

ConfigurableApplicationContext context = 
            new ClassPathXmlApplicationContext(new String[] {"Camera-Adapter.xml"});
    

ICameraControl theCameraControl = (ICameraControl)context.getBean("CameraControl");
        
theCameraControl.GetNextFrame ();