Bylo vydáno openSUSE Leap 16 (cs). Ve výchozím nastavení přichází s vypnutou 32bitovou (ia32) podporou. Uživatelům však poskytuje možnost ji ručně povolit a užívat si tak hraní her ve Steamu, který stále závisí na 32bitových knihovnách. Změnily se požadavky na hardware. Leap 16 nyní vyžaduje jako minimální úroveň architektury procesoru x86-64-v2, což obecně znamená procesory zakoupené v roce 2008 nebo později. Uživatelé se starším hardwarem mohou migrovat na Slowroll nebo Tumbleweed.
Ministerstvo průmyslu a obchodu (MPO) ve spolupráci s Národní rozvojovou investiční (NRI) připravuje nový investiční nástroj zaměřený na podporu špičkových technologií – DeepTech fond. Jeho cílem je posílit inovační ekosystém české ekonomiky, rozvíjet projekty s vysokou přidanou hodnotou, podpořit vznik nových technologických lídrů a postupně zařadit Českou republiku mezi země s nejvyspělejší technologickou základnou.
… více »Radicle byl vydán ve verzi 1.5.0 s kódovým jménem Hibiscus. Jedná se o distribuovanou alternativu k softwarům pro spolupráci jako např. GitLab.
Společnost OpenAI představila text-to-video AI model Sora 2 pro generování realistických videí z textového popisu. Přesnější, realističtější a lépe ovladatelný než předchozí modely. Nabízí také synchronizované dialogy a zvukové efekty.
UBports, nadace a komunita kolem Ubuntu pro telefony a tablety Ubuntu Touch, vydala Ubuntu Touch 24.04-1.0, tj. první stabilní vydání založené na Ubuntu 24.04 LTS.
Rakouská armáda přechází na LibreOffice. Ne kvůli licencím (16 000 počítačů). Hlavním důvodem je digitální suverenita. Prezentace v pdf z LibreOffice Conference 2025.
Národní úřad pro kybernetickou a informační bezpečnost (NÚKIB) upozorňuje na sérii kritických zranitelností v Cisco Adaptive Security Appliance (ASA) a Firepower Threat Defense (FTD) a Cisco IOS, CVE-2025-20333, CVE-2025-20363 a CVE-2025-20362. Zneužití těchto zranitelností může umožnit vzdálenému neautentizovanému útočníkovi spustit libovolný kód (RCE). Společnost Cisco uvedla, že si je vědoma aktivního zneužívání těchto zranitelností.
Ochrana uživatelů a zároveň příznivé podmínky pro rozvoj umělé inteligence (AI). Ministerstvo průmyslu a obchodu (MPO) připravilo minimalistický návrh implementace evropského nařízení o umělé inteligenci, tzv. AI aktu. Český zákon zajišťuje ochranu občanům a bezpečné používání AI, ale zároveň vytváří pro-inovační prostředí, ve kterém se může AI naplno rozvíjet, firmy mohou využít jeho potenciál a nebudou zatíženy zbytečnou administrativou. Návrh je nyní v meziresortním připomínkovém řízení.
Dle plánu Linus Torvalds odstranil souborový systém bcachefs z mainline Linuxu. Tvůrce bcachefs Kent Overstreet na Patreonu informuje, že bcachefs je nově distribuován jako DKMS modul.
PIF, Silver Lake a Affinity Partners kupují videoherní společnost Electronic Arts (EA) za 55 miliard dolarů (1,14 bilionu korun).
Nedávno jsem narazil na úžasný nový (pro mě), průmyslově ověřený funkcionální jazyk. Jmenuje se Erlang. Jeho vlastnosti mě přiměly říct wow! Posuďte sami. Za pozornost stojí například distributed (no on je to taky tak trochu komplet OS co se dokáže tvářit, že jede jako by jeden homogenní OS na heterogenním HW) a Hot code upgrade (viz example 14), nebo "Mnesia is a nice example of the power of Erlang: in how many languages could you write a fully-featured industrial-strength distributed DBMS in less than 20,000 lines of code?"
Napsal jsem, že je pro mě nový, ale on tak zas nový není, vznikl už kolem roku 1987 a stále se vyvíjí (4 release v roce 2006 a od začátku 2007 už stihl dva další - teda jedná se spíš o upgrade nadstaveb a nástrojů jako OTB). Má velmi lehké thready, například na AMD Athlon XP 2200+ má režii na vytvoření vlákna, přijetí zprávy a odeslání zprávy 2,1 us (včetně ukončení vlákna a garbage collectingu, testováno na 100 mil. vláknech, na samotnou zprávu padne asi 0,4 us)
Tak jsem si řekl, že si ho trošku ošahám. Jedna z prvních věcí, co mě zajímala (mimo jiné), byla existence nějakého dokumentačního systému. A měl ho tam, edoc. Takže jsem si napsal takový jednoduchý modulek a zkusil si ho v edocu zdokumentovat. Zároveň jsem si to chtěl troško o benchmarkovat a proto jsem si udělal takový malý generátor permutací. Tady je:
%% @copyright 2007 Hynek Vychodil %% @author Hynek Vychodil <pichi@nekde.top> %% [http://www.abclinuxu.cz/blog/Pichi] %% @version 0.0.1 %% @end %% ===================================================================== %% @doc perms - Permutation generator %% %% This module provides "simply" permutation generator with state support. %% %% == Usage == %%``` %%> perms:perms([a,b,c]). %%[[a,b,c],[a,c,b],[b,a,c],[b,c,a],[c,a,b],[c,b,a]] %%> perms:foreach(fun(P)->io:format("~p~n",[P]) end, [a,b,c]). %%[a,b,c] %%[a,c,b] %%[b,a,c] %%[b,c,a] %%[c,a,b] %%[c,b,a] %%ok %%> perms:foldl(fun(_,N)->N+1 end, 0, lists:seq(1,10)). %%3628800 %%> perms:map(fun(P)->lists:flatten(io_lib:write(P)) end, [a,b,c]). %%["[a,b,c]","[a,c,b]","[b,a,c]","[b,c,a]","[c,a,b]","[c,b,a]"] %%> {_,FS} = perms:first([a,b,c]). %%{[a,b,c],[{[b],[]},{[c],[b]},{[a,b,c],[]}]} %%> perms:next(FS). %%{[a,c,b],[{[c],[]},{[a,c],[]},{[b,c],[a]}]} %%> perms:next([{[c],[]},{[a,c],[]},{[b,c],[a]}]). %%{[b,a,c],[{[a],[]},{[c],[a]},{[b,c],[a]}]} %%> perms:nextState([{[a],[]},{[b],[a]},{[c],[b,a]}]). % e.g. last state -> [c,b,a] %%'$end_of_table' %%> perms:perm([{[a],[]},{[b],[a]},{[c],[b,a]}]). % see above %%[c,b,a] %%''' -module(perms). -export([first/1, next/1, perms/1, foreach/2, map/2, foldl/3, foldr/3]). -export([firstState/1, perm/1, nextState/1]). -import(lists, [reverse/1, reverse/2]). %% @spec (list()) -> {L::list(), State::state()} %% @type state() = [stack_entry()] | '$end_of_table' %% stack_entry() = { Todo::list(), Done::list() }. %% State is stack emulation of standard permutation generators %% %% @doc Makes first permutation (same as original `L') and `State' for next permutation. %% @see next/1 first(L) -> next(firstState(L)). %% @spec (state()) -> {P::list(), S2::state()} %% @doc Makes permutation `P' from current `S' {@type state()} and next `S2' {@type state()}. next(S) -> {perm(S), nextState(S)}. %% @spec (list()) -> State::state() %% @doc Makes first `State' ({@type state()}) for permutation of `L'. %% %% {@link perm/1} from this state makes original `L'. firstState(L) -> firstState(L, []). firstState([], Result) -> Result; firstState([_|Rest] = L, Result) -> firstState(Rest, [{L, []}|Result]). %% @spec (state()) -> P::list() %% @doc Makes permutation `P' from current `State'. %% @see firstState/1 %% @see nextState/1 %% @end %perm('$end_of_table') -> throw(beyond_end); perm(State) -> perm(State, []). perm([], Perm) -> Perm; perm([{[H|_], _}|RestOfState], Perm) -> perm(RestOfState, [H|Perm]). %% @spec (State::state()) -> Next::state() %% @doc Makes `Next' {@type state()} from current `State'. %% @end %nextState('$end_of_table') -> throw(beyond_end); nextState([]) -> '$end_of_table'; nextState([{[_], _}|State]) -> nextState(State); nextState([{[H|[_|TT]=T], Rest}|State]) -> firstState(reverse(Rest, [H|TT]), [{T, [H|Rest]}|State]). %% @spec (list()) -> Permutations::list() %% @doc Returns {@type list()} containing all `L''s permutations. perms(L) -> perms(firstState(L), []). perms('$end_of_table', Res) -> reverse(Res); perms(State, Res) -> {P, NS} = next(State), perms(NS, [P|Res]). %% @spec (F, list()) -> ok %% F = (P::list()) -> any() %% @doc Call `F' for each permutation `P' of `L'. foreach(F,L) -> foreachState(F, firstState(L)). foreachState(_, '$end_of_table') -> ok; foreachState(F, State) -> {P, NS} = next(State), F(P), foreachState(F, NS). %% @spec (F, list()) -> Result::list() %% F = (P::list()) -> Res %% Result = [Res] %% @doc Makes `Result' {@type list()} of `Res' results from calling `F' on each permutations `P' of `L'. map(F, L) -> map(F, firstState(L), []). map(_, '$end_of_table', Res) -> reverse(Res); map(F, State, Res) -> {P, NS} = next(State), map(F, NS, [F(P)|Res]). %% @spec (F, Acc0, list()) -> Acc %% F = (P::list(), AccIn) -> AccOut %% @doc Folds permutations of `L'. Calls `F' on each permutation of `L'. `Acc0' is passed as `AccIn' to firts `F' call %% and each `AccOut' is passed to next `F' call. %% Last `F' call result is returned as `Acc'. foldl(F, Acc0, L) -> foldlState(F, Acc0, firstState(L)). foldlState(_, Acc, '$end_of_table') -> Acc; foldlState(F, Acc, S) -> {P, NS} = next(S), foldlState(F, F(P, Acc), NS). %% @spec (F, Acc0, list()) -> Acc %% F = (P::list(), AccIn) -> AccOut %% @doc Same as {@link foldl/3} but in reverse order. foldr(F, Acc0, L) -> foldl(F, Acc0, reverse(L)).
Nic moc složitého, že? A přitom vygenerování 3 628 800 permutací desetiprvkové množiny a zavolání nějaké drobné funkce pro každou už tomu dá trošku zapotit, a taky že jo: cca 4,3 us na výše uvedeném Athlonu. Nic moc proti Alghoritm-Permute a 0,6 us (nejrychlejší = "call back" použití) na stejném stroji, ale to je psané přímo v C a vlastně nevím jestli jsem zvolil zrovna vhodný algoritmus. Snad mi vyjde čas zkusit totéž nativně v perlu, případně pythonu.
Copyright © 2007 Hynek Vychodil
Version: 0.0.1
Authors: Hynek Vychodil (pichi@nekde.top) [web site: http://www.abclinuxu.cz/blog/Pichi].
perms - Permutation generator
This module provides "simply" permutation generator with state support.
> perms:perms([a,b,c]). [[a,b,c],[a,c,b],[b,a,c],[b,c,a],[c,a,b],[c,b,a]] > perms:foreach(fun(P)->io:format("~p~n",[P]) end, [a,b,c]). [a,b,c] [a,c,b] [b,a,c] [b,c,a] [c,a,b] [c,b,a] ok > perms:foldl(fun(_,N)->N+1 end, 0, lists:seq(1,10)). 3628800 > perms:map(fun(P)->lists:flatten(io_lib:write(P)) end, [a,b,c]). ["[a,b,c]","[a,c,b]","[b,a,c]","[b,c,a]","[c,a,b]","[c,b,a]"] > {_,FS} = perms:first([a,b,c]). {[a,b,c],[{[b],[]},{[c],[b]},{[a,b,c],[]}]} > perms:next(FS). {[a,c,b],[{[c],[]},{[a,c],[]},{[b,c],[a]}]} > perms:next([{[c],[]},{[a,c],[]},{[b,c],[a]}]). {[b,a,c],[{[a],[]},{[c],[a]},{[b,c],[a]}]} > perms:nextState([{[a],[]},{[b],[a]},{[c],[b,a]}]). % e.g. last state -> [c,b,a] '$end_of_table' > perms:perm([{[a],[]},{[b],[a]},{[c],[b,a]}]). % see above [c,b,a]
state() = [stack_entry()] | '$end_of_table'
State is stack emulation of standard permutation generators
first/1 | Makes first permutation (same as original L ) and State for next permutation. |
firstState/1 | Makes first State (state() ) for permutation of L . |
foldl/3 | Folds permutations of L . |
foldr/3 | Same as foldl/3 but in reverse order. |
foreach/2 | Call F for each permutation P of L . |
map/2 | Makes Result list() of Res results from calling F on each permutations P of L . |
next/1 | Makes permutation P from current S state() and next S2 state() . |
nextState/1 | Makes Next state() from current State . |
perm/1 | Makes permutation P from current State . |
perms/1 | Returns list() containing all L 's permutations. |
first(L::list()) -> {L::list(), State::state()}
Makes first permutation (same as original L
) and State
for next permutation.
See also: next/1.
firstState(L::list()) -> State::state()
Makes first State
(state()
) for permutation of L
.
perm/1
from this state makes original L
.
foldl(F, Acc0, L::list()) -> Acc
Folds permutations of L
. Calls F
on each permutation of L
. Acc0
is passed as AccIn
to firts F
call
and each AccOut
is passed to next F
call.
Last F
call result is returned as Acc
.
foldr(F, Acc0, L::list()) -> Acc
Same as foldl/3
but in reverse order.
foreach(F, L::list()) -> ok
Call F
for each permutation P
of L
.
map(F, L::list()) -> Result::list()
Makes Result
list()
of Res
results from calling F
on each permutations P
of L
.
next(S::state()) -> {P::list(), S2::state()}
Makes permutation P
from current S
state()
and next S2
state()
.
nextState(State::state()) -> Next::state()
Makes Next
state()
from current State
.
perm(State::state()) -> P::list()
Makes permutation P
from current State
.
See also: firstState/1, nextState/1.
perms(L::list()) -> Permutations::list()
Returns list()
containing all L
's permutations.
Celkem to ujde a ještě se to nechá formátovat CSS a kvůli Abíčku jsem musel vyhodit nějaké ty atributy kolem tabulky. Kdyby jste si chtěli někdo obenchmarkovat thready a zprávy u sebe, tak ještě zdrojáky testů co jsem dělal
-module(ring). -export([start/1, start/2, server/1, child/1]). child(Parent) -> receive 0 -> Parent ! done; N -> Child = spawn(?MODULE, child, [Parent]), Child ! N-1 end. start(N) -> start(N, 10000). start(N, Timeout) -> process_flag(trap_exit, true), Parent = spawn_link(?MODULE, server, [Timeout]), statistics(wall_clock), Child = spawn(?MODULE, child, [Parent]), Child ! N, receive {'EXIT', Parent, ok} -> {_, T} = statistics(wall_clock), T/N/1000; {'EXIT', Parent, Reason} -> Reason end. server(Timeout) -> receive done -> exit(ok) after Timeout -> exit(timeout) end.
> c(ring). {ok,ring} > ring:start(pocet_opakovani) trvání jednoho v sec. nebo atom timeout pokud na to nestačilo 10s > ring:start(pocet_opakovani, timeout_v_ms) trvání jednoho v sec. nebo atom timeout pokud na to nestačil zadaný timeout
-module(pingperf). -export([start/1, pong/1]). pong(P) -> receive ping -> P ! pong, pong(P) end. ping(P, 0) -> exit(P, kill); ping(P, N) -> P ! ping, receive pong -> ping(P, N-1) end. start(N) -> statistics(wall_clock), PONG = spawn(?MODULE, pong, [self()]), ping(PONG, N), {_, T} = statistics(wall_clock), T/N/2000.
> c(pingperf). {ok,ring} > ring:start(pocet_opakovani) trvání zaslání jedné zprávy v sec.
Když už máme ten funkcionální jazyk, tak jde perms
pěkně přepsat pomocí map
(a taky nikam nespěchá, když chce vrátit všechny permutace )
--- perms.erl.old 2007-04-16 11:05:12.000000000 +0200 +++ perms.erl 2007-04-16 11:04:42.000000000 +0200 @@ -87,12 +87,8 @@ %% @spec (list()) -> Permutations::list() %% @doc Returns {@type list()} containing all `L''s permutations. -perms(L) -> perms(firstState(L), []). - -perms('$end_of_table', Res) -> reverse(Res); -perms(State, Res) -> - {P, NS} = next(State), - perms(NS, [P|Res]). +perms(L) -> map(fun identity/1, L). +identity(P) -> P. %% @spec (F, list()) -> ok %% F = (P::list()) -> any()
Tiskni
Sdílej:
modul:foo
místo jen foo
a bum a běží v nové verzi, typicky se tak píšou loop
smyčky serveru viz níže).
Samoupgradující server:loop(State) -> receive Msg -> NewState = do_some(State, Msg), ?MODULE:loop(NewState) end.Server s upgrade on demand:
loop(State) -> receive upgrade -> ?MODULE:loop(State); Msg -> NewState = do_some(State, Msg), loop(NewState) end.Pokud ten server má zpracovávat řádově stovky tisíc requestů za sekundu tak ten druhej kód bude o chlup rychlejší, ale zas musíš při upgrade zaslat ten signál.
Interpret možná přijde na řadu malinko později, jestli tím oslním svou slečnu, to sice nevím, ale zkusit to můžu (od mě jako od Matfyzáka už zažila mnohé ).Největší frajeřina by byla dát jí ho k narozeninám...tím samozřejmě myslím napsat ho tak kompaktní, aby se – napsaný polevou – vešel na horní stranu dortu.
foo
, tak to všechno běhá uvnitř té binárky snad i včetně imported funkcí (přímé adresy do verze jiného modulu, která byla v okamžiku natažení volajícího modulu, ale tím si nejsem jistý, možná, že to rovnou sahá po aktuální verzi) a v okamžiku požadavku na module:foo
se koukne do aktuálního slovníku (je to o chlup pomalejší) a skočí na nejnovější verzi (trošku to připomíná Debian a jeho větve init
modulu a dalších systémových věcí je trochu těžší, ale jak často měníš jádro, že BEAM
u, případně jádra, kompilátoru a loaderu. Zdrojáky jsou k dispozici