Neue Wege.
Unsere Projekte.

2017
Sanexio. Auf Udemy.

Demnächst starten wir unsere "letzCode"-Reihe auf Udemy. Bald findest Du hier Themen mit Schwerpunkten auf Webentwicklung, Android- und iOS-Programmierung sowie Netzwerktechnologien. Solange die Kurse noch nicht online sind, musst Du Dir leider das Profil vom GF anschauen.

Sanexio auf Udemy

2016
Sanexio. Auf GitHub.

Du willst weitere Informationen zu unseren Projekten und den Themen, die uns interessieren? Dann schau bei uns auf GitHub vorbei! Wir freuen und über jede Diskussion und Beteiligung auf unseren gelisteten Repositories.

SANEXIO auf GitHub

2016
Das CONNECT...Programm.

Connect verbindet Mediziner, Programmierer, Entwickler, Designer und alle anderen, die im digitalen Gesundheitsmarkt ihre Produkte und Dienstleistungen anbieten wollen. Wir sind der Überzeugung, dass alle Beteiligten auf dem Zukunftsmarkt „Gesundheit“ noch enger zusammenarbeiten müssen, um die anstehenden Herausforderungen zu bewältigen. Um gemeinsame Projekte im Bereich e-Health erfolgreich abzuschließen, braucht es ein gegenseitiges Verständnis für den Tätigkeitsbereich des jeweils anderen. Mit Connect wollen wir zwischen Medizin und IT Brücken bauen, gemeinsam an Projekten arbeiten und dabei auch noch Spaß haben.

Arbeite mit uns auf GitHub zusammen!

2015
Smart Contracts.

Das Bitcoin-Protokoll hat zu weiteren innovativen Entwicklungen geführt. Ein bedeutender Bereich ist die Entwicklung von Smart Contracts, welche Regeln, Verträge oder komplexe Prozesse in maschinenlesbaren Code übersetzen können. Wir setzen hierbei einen Schwerpunkt auf Applikationen aus dem Bereich Medizin, Managed Care sowie integrierter Versorgung. Aufgrund der Komplexität und der Einbindung verschiedener Programmiersprachen erfordert dies eine Moderation, um den notwendigen Bau von Werkzeugen und Entwicklertools zu fördern. SANEXIO will hierbei als Mediator die Beteiligten für medizinische Anwendungen zusammenführen.

Weitere Informationen in unserem Blog
  • dezentrale autonome versorgungsformen
    if tx.value < tx.basefee * 200: stop if contract.storage[tx.sender] == 0: stop k = sha3(32,tx.data[1]) if tx.data[0] == 0: if contract.storage[k + tx.sender] == 0: contract.storage[k + tx.sender] = 1 contract.storage[k] += 1 else if tx.data[0] == 1: if tx.value <= tx.datan * block.basefee * 200 or contract.storage[k]: stop i = 2 while i < tx.datan: contract.storage[k + i] = tx.data[i] i = i + 1 contract.storage[k] = 1 contract.storage[k+1] = tx.datan else if tx.data[0] == 2: if contract.storage[k] >= contract.storage[2 ^ 255] * 2 / 3: if tx.value <= tx.datan * block.basefee * 200: stop i = 3 L = contract.storage[k+1] loc = contract.storage[k+2] while i < L: contract.storage[loc+i-3] = tx.data[i] i = i + 1 if contract.storage[2 ^ 255 + 1] == 0: contract.storage[2 ^ 255 + 1] = 1 contract.storage[C] = 1
  • name registration
    if tx.value < block.basefee * 200: stop if contract.storage[tx.data[0]] or tx.data[0] < 100: stop contract.storage[tx.data[0]] = tx.data[1]
  • metacoin protocol
    if tx.output[0] != MARKER: break else if balance[tx.output[1]] < decode_value(tx.output[3]): break else if not tx.hasSignature(tx.output[1]): break else: balance[tx.output[1]] -= decode_value(tx.output[3]); balance[tx.output[2]] += decode_value(tx.output[3]);
  • sub-currencies
    init: # Initial: premine 1000000 units to creator contract.storage[msg.sender] = 1000000 code: # If a message with one item is sent, that's a balance query if msg.datasize == 1: addr = msg.data[0] return(contract.storage[addr]) # If a message with two items [to, value] are sent, that's a transfer request else: from = msg.sender fromvalue = contract.storage[from] to = msg.data[0] value = msg.data[1] if fromvalue >= value: contract.storage[from] = fromvalue - value contract.storage[to] = contract.storage[to] + value return(1) else: return(0)
  • data feed
    # Database updateable only by the original creator init: contract.storage[1000] = msg.sender code: // Message of the form [key, value] updates the database if msg.sender == contract.storage[1000] and msg.datasize == 2: contract.storage[msg.data[0]] = msg.data[1] // Database query else: return(contract.storage[msg.data[0]])
  • hedging contract
    if tx.value < 200 * block.basefee: stop if contract.storage[1000] == 0: if tx.value < 1000 * 10^18: stop contract.storage[1000] = 1 contract.storage[1001] = 998 * block.contract_storage(D)[I] contract.storage[1002] = block.timestamp + 30 * 86400 contract.storage[1003] = tx.sender else: ethervalue = contract.storage[1001] / block.contract_storage(D)[I] if ethervalue >= 5000: mktx(contract.storage[1003],5000 * 10^18,0,0) else if block.timestamp > contract.storage[1002]: mktx(contract.storage[1003],ethervalue * 10^18,0,0) mktx(A,(5000 - ethervalue) * 10^18,0,0)
  • crowd fund
    if msg.data[0] == 0: # Start a campaign, data [goal, time limit] id = contract.storage[-1] contract.storage[-1] = id + 2^128 contract.storage[id] = msg.sender // Campaign creator contract.storage[id + 1] = msg.data[1] // Goal contract.storage[id + 2] = block.timestamp + msg.data[2] // Time limit contract.storage[id + 3] = id + 5 // Start recording donations here // contract.storage[id + 4] is a running counter return(id) elif msg.data[0] == 1: # Contribute to a campaign [id] id = msg.data[1] val = contract.storage[id + 4] contract.storage[id + 4] = val + msg.value sub_index = contract.storage[id + 3] contract.storage[sub_index] = msg.sender contract.storage[sub_index + 1] = msg.value contract.storage[id + 3] = sub_index + 2 # Enough funding? if val + msg.value >= contract.storage[id + 1]: send(contract.storage[id], val + msg.value) v = id f = sub_index + 2 while v < f: contract.storage[v] = 0 v += 1 return(1) # Expired? if block.timestamp > contract.storage[id + 2]: v = id f = sub_index + 2 while v < id + 5: contract.storage[v] = 0 v += 1 while v < f: send(contract.storage[v], contract.storage[v + 1]) contract.storage[v] = 0 contract.storage[v + 1] = 0 v += 2 return(2) elif msg.data[0] == 2: # Progress report [id] return(contract.storage[msg.data[1]] + 4)
  • namecoin
    // Namecoin if !contract.storage[msg.data[0]]: # Is the key not yet taken? # Then take it! contract.storage[msg.data[0]] = msg.data[1] return(1) else: return(0) // Otherwise do nothing
  • quick sort
    if msg.datasize < 2: return(msg.data, msg.datasize) else: low = array(msg.datasize) lsz = 0 high = array(msg.datasize) hsz = 0 i = 1 while i < msg.datasize: if msg.data[i] < msg.data[0]: low[lsz] = msg.data[i] lsz += 1 else: high[hsz] = msg.data[i] hsz += 1 i = i + 1 low = call(contract.address, low, lsz, lsz) high = call(contract.address, high, hsz, hsz) o = array(msg.datasize) i = 0 while i < lsz: o[i] = low[i] i += 1 o[lsz] = msg.data[0] j = 0 while j < hsz: o[lsz + 1 + j] = high[j] j += 1 return(o, msg.datasize)
  • schellingcoin
    # SchellingCoin implementation # # Stored variables: # # 0: last_processed_block # 1: number of hashes submitted # 2: value # 3: quicksort_pairs address # # 2^160 + 3x: hash # 2^160 + 3x + 1: deposit # 2^160 + 3x + 2: address # 2^170 + x: value # # Transaction types: # # [1, sha3([address, value])] -> id: submit hash (only works when block number mod 100 < 50) # # [2, id, value]: submit answer (only works when block number mod 100 >= 50) # # [3]: balance query # # [4]: value query # # Parameters: # # Epoch length: 100 blocks # Target savings depletion rate: 0.1% per epoch init: contract.storage[0] = block.number contract.storage[3] = create('quicksort_pairs.se') code: HASHES = 2^160 VALUES = 2^170 if block.number / 100 > contract.storage[0] / 100: # Sort all hashes N = contract.storage[1] o = array(N) i = 0 j = 0 while i < N: if contract.storage[VALUES + i]: o[j] = contract.storage[VALUES + i] o[j + 1] = i j += 2 i += 1 values = call(contract.storage[3], o, j, j) # Calculate total deposit, refund non-submitters and # cleanup deposits = array(j / 2) addresses = array(j / 2) i = 0 total_deposit = 0 while i < j / 2: base_index = HASHES + values[i * 2 + 1] * 3 contract.storage[base_index] = 0 deposits[i] = contract.storage[base_index + 1] contract.storage[base_index + 1] = 0 addresses[i] = contract.storage[base_index + 2] contract.storage[base_index + 2] = 0 if contract.storage[VALUES + values[i * 2 + 1]]: total_deposit += deposits[i] else: send(addresses[i], deposits[i] * 999 / 1000) i += 1 inverse_profit_ratio = total_deposit / (contract.balance / 1000) + 1 # Reward everyone i = 0 running_deposit_sum = 0 halfway_passed = 0 while i < j / 2: new_deposit_sum = running_deposit_sum + deposits[i] if new_deposit_sum > total_deposit / 4 and running_deposit_sum < total_deposit * 3 / 4: send(addresses[i], deposits[i] + deposits[i] / inverse_profit_ratio * 2) else: send(addresses[i], deposits[i] - deposits[i] / inverse_profit_ratio) if not halfway_passed and new_deposit_sum > total_deposit / 2: contract.storage[2] = contract.storage[VALUES + i] halfway_passed = 1 contract.storage[VALUES + i] = 0 running_deposit_sum = new_deposit_sum i += 1 contract.storage[0] = block.number contract.storage[1] = 0 # Hash submission if msg.data[0] == 1: if block.number % 100 < 50: cur = contract.storage[1] pos = HASHES + cur * 3 contract.storage[pos] = msg.data[1] contract.storage[pos + 1] = msg.value contract.storage[pos + 2] = msg.sender contract.storage[1] = cur + 1 return(cur) # Value submission elif msg.data[0] == 2: if sha3([msg.sender, msg.data[2]], 2) == contract.storage[HASHES + msg.data[1] * 3]: contract.storage[VALUES + msg.data[1]] = msg.data[2] return(1) # Balance request elif msg.data[0] == 3: return(contract.balance) # Value request else: return(contract.storage[2])

2014
JUVANTIS. - 1.0

Mit JUVANTIS entwickeln und implementieren wir für den Bereich der präventiven Medizin eine innovative Plattform, die den Informationsfluss zwischen medizinischem Fachpersonal und Patienten erleichtern und beiden Seiten die Möglichkeit geben soll, medizinische Gesundheitsdaten mit den schon etablierten Methoden der Telemedizin und den Möglichkeiten des häuslichen Monitorings besser zu nutzen und auszuwerten. Das richtige Filtern und Auswerten dieser Daten ermöglicht es, eine persönlichere und auf die jeweilige Person abgestimmte Medizin zu praktizieren. Wir bezeichnen diese innovative Art des Austausches als „Digital therapeutics“, da wir das Netz nicht nur als Medium der Informationsvermittlung und des Erfahrungsaustausches sehen, sondern über die Möglichkeiten der gezielten Profileingabe und –suche eine dedizierte personalisierte Medizin erreichen wollen.

Weitere Informationen in unserem Blog

2013
Sanexio Pages.

Auch der niedergelassene Arztberuf wandelt sich immer mehr zum vernetzten Dienstleister. Eine Homepage für Ärzte mit den Schnittstellen für Anwendungen aus dem Bereich E-Health stellt hierbei den ersten Schritt dar. Mit der Plattform Sanexio PAGES liefern wir ein umfassendes Content Management System für eine bessere Vernetzung von medizinischem Fachpersonal untereinander und mit den Patienten. Angefangen von der Möglichkeit der Onlineterminanfrage bis hin zu Konzepten aus dem Bereich Telemedizin oder Telecare entlasten unsere Softwarelösungen den Arzt und sein Team. Gleichzeitig können die Patienten neue Wege ihrer Krankheitsbehandlung oder Gesundheitsvorsorge gehen.

SANEXIOpages

2013
VulkanoMed

Immer mehr Kommunen stehen vor der Herausforderung, die regionale Infrastruktur verschiedener sozialer Versorgungsleistungen aufrecht zu erhalten. Neben dem gemeinnützigen Betrieb von Sport- und Freizeitzentren sowie Bildungs-, Pflege- und Betreuungseinrichtungen ist insbesondere die flächendeckende medizinische Versorgung vom Wegfall bedroht. Auch im Vogelsbergkreis gilt die Daseinsvorsorge nach wie vor als eine der Kernaufgaben kommunaler Entscheidungsträger, zumal diese auch für die Bereitstellung stationärer Versorgung verantwortlich sind.
Vor diesem Hintergrund hat Sanexio für die Stadt Ulrichstein ein Konzept entwickelnt, wie die Sicherstellung einer wohnortnahen Gesundheitsversorgung im Landkreis Vogelsberg beschritten und dabei neue Formen der Zusammenarbeit zwischen stationärem und ambulantem Bereich mit den Kommunen entwickelt werden können.

Projekt auf GitHub

2012
DOCVOCAT.

DOCVOCAT ist ein Netzwerk für Ärzte und medizinische Einrichtungen, um beiden Seiten einen schnellen Kontakt und den unkomplizierten Austausch von Informationen über einen eigens hierfür entwickelten Matchingalgorithmus zu ermöglichen. Wir haben DOCVOCAT entwickelt, weil wir selbst als freiberufliche Ärzte in Deutschland arbeiten und die Erfahrung gemacht haben, dass es hierbei viele Hürden gibt, die wir anderen gerne ersparen möchten. Wir möchten anderen Kollegen dabei helfen, interessante Arbeitsplätze kennenzulernen, neue Erfahrungen zu sammeln und den beruflichen Horizont zu erweitern. Dabei ersparen wir Ihnen die aufwändige Bürokratie.

DOCVOCAT