Übersetzung für "Nebenläufigkeit" in Englisch
																						Eine
																											weitere
																											Stärke
																											von
																											Node.js,
																											ist
																											die
																											Abstraktion
																											der
																											Nebenläufigkeit.
																		
			
				
																						Another
																											strength
																											of
																											Node.js
																											is
																											its
																											abstraction
																											of
																											concurrency.
															 
				
		 ParaCrawl v7.1
			
																						Lawrence
																											Snyder
																											erklärt,
																											dass
																											ein
																											Algorithmus
																											mit
																											einer
																											Komplexität
																											in
																											O(N3)
																											durch
																											Verdopplung
																											der
																											Nebenläufigkeit
																											einen
																											von
																											nur
																											9
																											%
																											erzielt.
																		
			
				
																						Snyder
																											points
																											out
																											an
																											O(N3)
																											algorithm
																											means
																											that
																											double
																											the
																											concurrency
																											gives
																											only
																											about
																											a
																											26%
																											increase
																											in
																											problem
																											size.
															 
				
		 Wikipedia v1.0
			
																						Lawrence
																											Snyder
																											erklärt,
																											dass
																											ein
																											Algorithmus
																											mit
																											einer
																											Komplexität
																											in
																											O(N3)
																											durch
																											Verdopplung
																											der
																											Nebenläufigkeit
																											einen
																											SpeedUp
																											von
																											nur
																											9
																											%
																											erzielt.
																		
			
				
																						Snyder
																											points
																											out
																											an
																											O(N3)
																											algorithm
																											means
																											that
																											double
																											the
																											concurrency
																											gives
																											only
																											about
																											a
																											26%
																											increase
																											in
																											problem
																											size.
															 
				
		 WikiMatrix v1
			
																						Aufgrund
																											seines
																											Expertenwissens
																											in
																											den
																											Bereichen
																											Programmanalyse
																											und
																											-verifikation
																											der
																											Software
																											von
																											eingebetteten
																											Systemen,
																											Design
																											von
																											Programmiersprachen
																											und
																											-modellen
																											für
																											Parallelität
																											und
																											Nebenläufigkeit,
																											und
																											seines
																											umfangreichen
																											Know-hows
																											in
																											der
																											Softwarearchitektur
																											für
																											verteilte
																											eingebettete
																											Echtzeitsysteme
																											deckt
																											das
																											Institut
																											aktuelle
																											Trends
																											in
																											der
																											Robotik
																											sehr
																											gut
																											ab.
																		
			
				
																						Current
																											trends
																											in
																											robotics
																											are
																											well
																											covered
																											by
																											the
																											institute's
																											expertise
																											in
																											program
																											analysis
																											and
																											verification
																											of
																											embedded
																											systems
																											software,
																											the
																											design
																											of
																											programming
																											languages
																											and
																											models
																											for
																											parallelism
																											and
																											concurrency,
																											and
																											extensive
																											know-how
																											in
																											software
																											architecture
																											for
																											distributed
																											embedded
																											real-time
																											systems.
																											Â
															 
				
		 ParaCrawl v7.1
			
																						Die
																											Nebenläufigkeit
																											basiert
																											auf
																											dem
																											Actor
																											Model,
																											bei
																											dem
																											ein
																											abgeschlossener
																											Prozess
																											mit
																											anderen
																											Prozessen
																											durch
																											message
																											passing
																											kommuniziert.
																		
			
				
																						The
																											concurrency
																											model
																											relies
																											on
																											Actors,
																											a
																											contained
																											process
																											that
																											communicates
																											with
																											other
																											processes
																											through
																											message
																											passing.
															 
				
		 ParaCrawl v7.1
			
																						Sie
																											können
																											moderne
																											Klassenbibliotheken
																											zur
																											Umsetzung
																											von
																											Aufgabenstellungen
																											in
																											objektorientierte
																											Software
																											einsetzen
																											sowie
																											die
																											technischen
																											Mög-lichkeiten
																											moderner
																											Laufzeitumgebungen
																											(z.B.
																											Nebenläufigkeit,
																											Sicherheitsmechanismen,
																											Introspektion)
																											nut-zen.
																		
			
				
																						They
																											can
																											apply
																											modern
																											class
																											libraries
																											to
																											implement
																											tasks
																											in
																											object-oriented
																											software
																											and
																											use
																											the
																											technical
																											options
																											of
																											modern
																											runtime
																											environments
																											(e.g.
																											concurrency,
																											security
																											mechanisms,
																											introspection).
															 
				
		 ParaCrawl v7.1
			
																						Da
																											es
																											sich
																											bei
																											dem
																											System
																											um
																											ein
																											aus
																											mehreren
																											Entwicklungsumgebungen
																											und
																											Maschinensteuerungen
																											bestehendes
																											verteiltes
																											System
																											mit
																											mehreren
																											Komponenten
																											handelt,
																											hat
																											auch
																											der
																											Programmcode
																											vorzugsweise
																											die
																											Form
																											eines
																											verteilten
																											Softwaresystems
																											und
																											macht
																											bevorzugt
																											von
																											den
																											Methoden
																											der
																											verteilten
																											Programmierung
																											wie
																											der
																											Nebenläufigkeit
																											von
																											Prozessen
																											und
																											Threads
																											oder
																											der
																											asynchronen
																											Kommunikation
																											zwischen
																											verschiedenen
																											Komponenten
																											Gebrauch.
																		
			
				
																						Since
																											this
																											is
																											a
																											distributed
																											system
																											consisting
																											of
																											several
																											development
																											environments
																											and
																											machine
																											control
																											systems
																											with
																											multiple
																											components,
																											the
																											program
																											code
																											has
																											preferably
																											also
																											the
																											form
																											of
																											a
																											distributed
																											software
																											system,
																											and
																											preferably
																											uses
																											the
																											methods
																											of
																											distributed
																											programming,
																											such
																											as
																											the
																											concurrency
																											of
																											processes
																											and
																											threads,
																											or
																											asynchronous
																											communication
																											between
																											the
																											various
																											components.
															 
				
		 EuroPat v2
			
																						Daneben
																											ist
																											der
																											Bootloader
																											aber
																											auch
																											ein
																											wichtiges
																											Werkzeug
																											bei
																											der
																											Inbetriebnahme
																											neuer
																											Hardware:
																											da
																											es
																											im
																											Bootloader
																											noch
																											keine
																											Nebenläufigkeit
																											und
																											keine
																											Interrupts
																											gibt,
																											man
																											aber
																											bereits
																											auf
																											Hardware
																											zugreifen
																											kann,
																											ist
																											er
																											auch
																											bei
																											Hardwerkern
																											beliebt.
																		
			
				
																						In
																											addition,
																											the
																											boot
																											loader
																											is
																											also
																											an
																											important
																											tool
																											for
																											the
																											bring-up
																											of
																											new
																											hardware:
																											since
																											the
																											bootloader
																											does
																											not
																											have
																											any
																											concurrency
																											or
																											interrupts,
																											and
																											provides
																											direct
																											access
																											to
																											hardware,
																											it
																											is
																											also
																											popular
																											with
																											hardware
																											developers.
															 
				
		 CCAligned v1
			
																						Wir
																											haben
																											uns
																											die
																											Elixir-Abstraktion
																											für
																											Nebenläufigkeit
																											angesehen,
																											aber
																											manchmal
																											hätten
																											wir
																											gern
																											mehr
																											Kontrolle
																											und
																											dafür
																											sehen
																											wir
																											uns
																											OTP
																											behaviors
																											an,
																											auf
																											denen
																											Elixir
																											gebaut
																											wurde.
																		
			
				
																						We’ve
																											looked
																											at
																											the
																											Elixir
																											abstractions
																											for
																											concurrency
																											but
																											sometimes
																											we
																											need
																											greater
																											control
																											and
																											for
																											that
																											we
																											turn
																											to
																											the
																											OTP
																											behaviors
																											that
																											Elixir
																											is
																											built
																											on.
															 
				
		 CCAligned v1
			
																						Katoens
																											Forschungsinteressen
																											umfassen
																											formale
																											Methoden,
																											formale
																											Verifikation,
																											im
																											Speziellen
																											Model
																											Checking,
																											Nebenläufigkeit,
																											und
																											Semantik,
																											besonders
																											Semantik
																											von
																											probabilistischen
																											Programmiersprachen.
																		
			
				
																						Katoen's
																											main
																											research
																											interests
																											are
																											formal
																											methods,
																											computer
																											aided
																											verification,
																											in
																											particular
																											model
																											checking,
																											concurrency
																											theory,
																											and
																											semantics,
																											in
																											particular
																											semantics
																											of
																											probabilistic
																											programming
																											languages.
															 
				
		 WikiMatrix v1
			
																						Ich
																											habe
																											mir
																											angeschaut,
																											wie
																											Nebenläufigkeit
																											in
																											Entitäten
																											zu
																											verwalten
																											ist,
																											aber
																											ich
																											konnte
																											keine
																											guten
																											aktualisierten
																											Informationen
																											über
																											die
																											empfohlenen
																											Prozeduren
																											für
																											den
																											gemeinsamen
																											Umgang
																											mit
																											Entitäten
																											7
																											finden.
																		
			
				
																						I
																											was
																											having
																											a
																											look
																											at
																											how
																											to
																											manage
																											concurrency
																											in
																											entities
																											but
																											I
																											couldn't
																											find
																											any
																											good
																											updated
																											information
																											about
																											the
																											recommended
																											concurrency
																											handling
																											practices
																											for
																											Entity
																											7.
															 
				
		 CCAligned v1
			
																						Noch
																											vor
																											dem
																											Mittagessen
																											erläuterte
																											Heinz
																											uns
																											seine
																											Gesetze
																											über
																											Nebenläufigkeit,
																											welche
																											er
																											bereits
																											in
																											verkürzter
																											Form
																											auf
																											unserem
																											meet
																											the
																											experts
																											–
																											performance
																											event
																											präsentierte.
																		
			
				
																						Before
																											the
																											lunch
																											break,
																											Heinz
																											showed
																											us
																											his
																											laws
																											on
																											concurrency,
																											which
																											he
																											also
																											presented
																											in
																											an
																											abbreviated
																											form
																											at
																											our
																											meet
																											the
																											experts
																											–
																											performance
																											event.
															 
				
		 ParaCrawl v7.1
			
																						Hehner,
																											der
																											seinen
																											Vortrag
																											mit
																											Schwerpunkt
																											Nebenläufigkeit
																											fortsetzte,
																											erkannte
																											das
																											wahre
																											Problem
																											der
																											``dinierenden
																											Philosophen'':
																		
			
				
																						Hehner,
																											who
																											continued
																											his
																											talk
																											with
																											a
																											focus
																											on
																											concurrency,
																											detected
																											the
																											real
																											problem
																											of
																											the
																											``dining
																											philosophers'':
															 
				
		 ParaCrawl v7.1
			
																						Mithilfe
																											von
																											Techniken
																											wie
																											setTimeout(),
																											setInterval(),
																											XMLHttpRequest
																											und
																											Ereignis-Handlern
																											ahmen
																											Entwickler
																											eine
																											Nebenläufigkeit
																											nach.
																		
			
				
																						Developers
																											mimic
																											'concurrency'
																											by
																											using
																											techniques
																											like
																											setTimeout(),
																											setInterval(),
																											XMLHttpRequest,
																											and
																											event
																											handlers.
															 
				
		 ParaCrawl v7.1
			
																						Es
																											ist
																											daher
																											wichtig
																											im
																											Hinterkopf
																											zu
																											haben,
																											dass
																											beim
																											CMS
																											Collector
																											trotz
																											der
																											Nebenläufigkeit
																											die
																											Gefahr
																											einer
																											Full
																											GC
																											(und
																											damit
																											einer
																											sehr
																											langen
																											Pausenzeit)
																											immer
																											noch
																											existiert.
																		
			
				
																						Thus,
																											despite
																											all
																											the
																											concurrency
																											that
																											the
																											CMS
																											Collector
																											brings,
																											there
																											is
																											still
																											a
																											risk
																											of
																											a
																											long
																											stop-the-world
																											pause
																											happening.
															 
				
		 ParaCrawl v7.1
			
																						Sinatra
																											selbst
																											ist
																											Thread-sicher,
																											somit
																											ist
																											es
																											kein
																											Problem
																											wenn
																											der
																											Rack-Proxy
																											ein
																											anderes
																											Threading-Modell
																											für
																											Nebenläufigkeit
																											benutzt.
																		
			
				
																						Sinatra
																											itself
																											is
																											thread-safe,
																											so
																											there
																											won’t
																											be
																											any
																											problem
																											if
																											the
																											Rack
																											handler
																											uses
																											a
																											threaded
																											model
																											of
																											concurrency.
															 
				
		 ParaCrawl v7.1
			
																						Sie
																											können
																											moderne
																											Klassenbibliotheken
																											zur
																											Umsetzung
																											von
																											Aufgabenstellungen
																											in
																											objektorientierte
																											Software
																											einsetzen
																											sowie
																											die
																											technischen
																											Möglichkeiten
																											moderner
																											Laufzeitumgebungen
																											(z.B.
																											Nebenläufigkeit,
																											Introspektion)
																											nutzen.
																		
			
				
																						They
																											can
																											use
																											modern
																											class
																											libraries
																											to
																											implement
																											tasks
																											in
																											object-oriented
																											software
																											as
																											well
																											as
																											the
																											technical
																											opportunities
																											of
																											modern
																											run-time
																											environments
																											(e.g.
																											concurrency,
																											introspection).
															 
				
		 ParaCrawl v7.1
			
																						Sie
																											können
																											moderne
																											Klassenbibliotheken
																											zur
																											Umsetzung
																											von
																											Auf-gabenstellungen
																											in
																											objektorientierte
																											Software
																											einsetzen
																											sowie
																											die
																											technischen
																											Möglichkeiten
																											moderner
																											Lauf-zeitumgebungen
																											(z.B.
																											Nebenläufigkeit,
																											Introspektion)
																											nutzen.
																		
			
				
																						They
																											can
																											use
																											modern
																											class
																											libraries
																											to
																											implement
																											tasks
																											in
																											object-oriented
																											software
																											as
																											well
																											as
																											the
																											technical
																											opportunities
																											of
																											modern
																											run-time
																											environments
																											(e.g.
																											concurrency,
																											security
																											mechanisms,
																											introspection).
															 
				
		 ParaCrawl v7.1
			
																						Zusammenfassend
																											läßt
																											sich
																											festhalten,
																											daß
																											alle
																											Versuche
																											Programmiersprachen
																											mit
																											Unterroutinen
																											und
																											gemeinsamen
																											Zustandsraum
																											um
																											Nebenläufigkeit
																											zu
																											erweitern
																											zu
																											erhöhter
																											Komplexität,
																											aufwendigen
																											Implementierungen
																											und
																											Fehlern
																											im
																											Programmieren,
																											die
																											schwer
																											zu
																											beheben
																											sind,
																											führten.
																		
			
				
																						In
																											summary,
																											attempts
																											to
																											add
																											concurrency
																											to
																											languages
																											with
																											subroutines
																											and
																											shared
																											state
																											lead
																											to
																											complexity,
																											costly
																											implementations
																											of
																											processes,
																											and
																											bugs
																											that
																											are
																											very
																											hard
																											to
																											track
																											down.
																											ToonTalk,
																											in
																											contrast,
																											was
																											designed
																											from
																											scratch
																											to
																											be
																											concurrent.
															 
				
		 ParaCrawl v7.1
			
																						Das
																											Resultat
																											ist
																											eine
																											den
																											Hardwaredesignern
																											vertraute
																											Kodierungsart,
																											mit
																											der
																											sie
																											die
																											Kommunikation,
																											Prioritäten
																											und
																											Aufgabenkoordination
																											innerhalb
																											einer
																											abstrakten
																											Darstellung
																											der
																											Nebenläufigkeit
																											mühelos
																											ausdrücken
																											können.
																		
			
				
																						The
																											result
																											is
																											a
																											coding
																											style
																											familiar
																											to
																											hardware
																											designers,
																											letting
																											users
																											easily
																											express
																											communication,
																											priority
																											and
																											task
																											coordination
																											within
																											an
																											abstract
																											representation
																											of
																											concurrency.
															 
				
		 ParaCrawl v7.1
			
																						Die
																											eigentliche
																											Nebenläufigkeit
																											wird
																											durch
																											die
																											Ereignisschleife
																											(engl.
																											event
																											loop)
																											in
																											einem
																											einzigen
																											Thread
																											verwaltet.
																		
			
				
																						The
																											concurrency
																											is
																											handled
																											by
																											the
																											event
																											loop
																											in
																											a
																											single
																											thread.
															 
				
		 ParaCrawl v7.1
			
																						Sie
																											hängt
																											nicht
																											von
																											der
																											Zahl
																											der
																											registrierten
																											oder
																											zu
																											einem
																											Zeitpunkt
																											in
																											Moodle
																											angemeldeten
																											Nutzer/innen
																											ab.
																											Der
																											Begriff
																											"gleichzeitige
																											Nutzer/innen"
																											bezeichnet
																											Nutzer/innen,
																											für
																											die
																											der
																											Server
																											zu
																											einem
																											bestimmten
																											Zeitpunkt
																											aktiv
																											etwas
																											tut:
																											eine
																											Webseite
																											verarbeiten,
																											die
																											in
																											PHP
																											geschrieben
																											ist,
																											eine
																											Datenbankabfrage
																											durchführen,
																											eine
																											Datei
																											ausliefern
																											usw.,
																											siehe
																											auch
																											diesen
																											Wikipedia-Artikel
																											zu
																											Nebenläufigkeit
																											.
																		
			
				
																						Not
																											on
																											the
																											total
																											number
																											of
																											user
																											accounts
																											and
																											not
																											on
																											the
																											number
																											of
																											users
																											logged-in.
																											The
																											term
																											"concurrent
																											users"
																											is
																											used
																											to
																											mean
																											those
																											users
																											for
																											whom
																											the
																											server
																											is
																											actively
																											doing
																											something
																											.
																											It
																											may
																											by
																											processing
																											a
																											webpage
																											written
																											in
																											PHP,
																											querying
																											the
																											database
																											or
																											simply
																											transferring
																											a
																											file.
																											(see
																											also
																											Wikipedia
																											Concurrency).
															 
				
		 ParaCrawl v7.1
			
																						Bevor
																											ich
																											die
																											nebenläufige
																											Berechnung
																											in
																											ToonTalk
																											erläutere
																											und
																											darauf
																											eingehe
																											weshalb
																											es
																											schwierig
																											ist,
																											sequentielle
																											Sprachen
																											auf
																											Parallelität
																											zu
																											erweitern,
																											werde
																											ich
																											die
																											Beziehung
																											zwischen
																											Nebenläufigkeit,
																											Parallelität
																											und
																											verteiltes
																											Berechnen
																											erklären.Parallele
																											Prozesse
																											sind
																											Prozesse,
																											die
																											alle
																											auf
																											dem
																											selben
																											Computersystem
																											ausgeführt
																											werden.
																		
			
				
																						Before
																											I
																											attempt
																											to
																											explain
																											concurrent
																											computation
																											in
																											ToonTalk
																											and
																											why
																											it
																											is
																											difficult
																											to
																											extend
																											sequential
																											languages
																											to
																											be
																											concurrent,
																											I'll
																											explain
																											the
																											relationship
																											between
																											concurrency,
																											parallelism,
																											and
																											distributed
																											computing.
																											Parallel
																											processes
																											are
																											processes
																											that
																											are
																											running
																											within
																											the
																											same
																											computer
																											system.
															 
				
		 ParaCrawl v7.1