ledentsov.de DLed : Programming / Photography / Music / Notes - Programming / Photography / Music / Notes

Title: DLed : Programming / Photography / Music / Notes - Programming / Photography / Music / Notes
Description: Programming / Photography / Music / Notes
ledentsov.de is ranked 6629093 in the world (amongst the 40 million domains). A low-numbered rank means that this website gets lots of visitors. This site is relatively popular among users in the united states. It gets 50% of its traffic from the united states .This site is estimated to be worth $2,832. This site has a low Pagerank(0/10). It has 1 backlinks. ledentsov.de has 43% seo score.

ledentsov.de Information

Website / Domain: ledentsov.de
Website IP Address:
Domain DNS Server: ns02.one.com,ns01.one.com,ns03.one.com

ledentsov.de Rank

Alexa Rank: 6629093
Google Page Rank: 0/10 (Google Pagerank Has Been Closed)

ledentsov.de Traffic & Earnings

Purchase/Sale Value: $2,832
Daily Revenue: $7
Monthly Revenue $232
Yearly Revenue: $2,832
Daily Unique Visitors 714
Monthly Unique Visitors: 21,420
Yearly Unique Visitors: 260,610

ledentsov.de WebSite Httpheader

StatusCode 200
Content-Type text/html; charset=UTF-8
Date Thu, 28 Jul 2016 04:59:12 GMT
Server Apache

ledentsov.de Keywords accounting

Keyword Count Percentage

ledentsov.de Traffic Sources Chart

ledentsov.de Similar Website

Domain Site Title

ledentsov.de Alexa Rank History Chart

ledentsov.de aleax

ledentsov.de Html To Plain Text

DLed : Programming / Photography / Music / Notes - Programming / Photography / Music / Notes DLed : Programming / Photography / Music / Notes Programming / Photography / Music / Notes Menu Skip to content Home Programming Photography Music About Disclaimer A unit test suite is a spiderweb Leave a reply A moment’s epiphany in a highly caffeinated brain; a metaphor: a unit test suite is a spiderweb!1 Why? It’s lightweight It’s sufficiently robust It catches a casual bug passing by It’s most useful if the maintainer reacts to a bug catch immediately It needs occasional maintenance It’s not watertight, but good enough Some are beautifully designed, some look like a tight cloth, some are a mess …insert your analogy… There is an already established XP metaphor of a safety net for the people and the business, to which I fully subscribe. This “lightweight net” metaphor, I hope, adds another flavor to the test-suite-as-a-net analogies, especially, to lightweight unit test suites, by describing which qualities unit test suites can have. We now know that small (biological) bugs and other small creatures can cause a lot of harm, just as tiny software bugs can and do. 2 The analogy might have been a cheap trick of my brain. Nonetheless, it is now externalized, and I can go to sleep. When done well ? As a corollary: one can catch larger things by being a large cat, and applying different powerful strategies, but that requires quite a muscle mass, and a good connection to the ground. P.S. no lightweight vs. non-lightweight preference comparison intended. ? This entry was posted in DLed, Programming and tagged analogy, bugs, cobweb, lightweight, quality, software, spider web, spiderweb, tdd, test suite, unit test, unit testing on February 1, 2016 by DLed. Итого: 2015 / Balance: 2015 Leave a reply Year 2015 Summary 2015 – A year of fast paced change → 2014 This entry was posted in DLed, Photography, Review and tagged 2013, DLed, London, photo, review, Rosalia Wanka, year, итого on January 1, 2016 by DLed. Why wait forever for the tests? Fast tests of slow software. Leave a reply Contents 1 Time is volatile 2 Slow non-tests 3 Fast tests 4 Source Time is volatile Imagine writing a cron-like functionality that should produce some side-effect, such as cleanup. The intervals between such actions might be quite long. How does one test that? One can surely reason about the software, but given a certain complexity, test should be written, proving that certain important scenarios work as intended. It’s common that software depends on time flow as dictated by the physical time flow, reflected via some clock provider. However, resetting the time to a year ahead won’t make the CPU work faster and make all the computations it should have performed within that year. A clock is also a volatile component that can be manipulated, thus if time is an issue, it’s probably a good idea not to depend on it directly, following the Stable Dependencies Principle and the Dependency Inversion Principle. Luckily, there is an abstraction for time, at least in Reactive Extensions (Rx), which is the Scheduler. Slow non-tests Here’s a slow Groovy non-test, waiting for some output on the console using RxGroovy: import rx.* import java.util.concurrent.TimeUnit def observable = Observable .just(1) .delay(5, TimeUnit.SECONDS) observable.subscribe { println 'ah, OK, done! Or not?' } Observable .interval(1,TimeUnit.SECONDS) .subscribe { println 'still waiting...' } println 'starting to wait for the test to complete ...' observable.toBlocking().last() Running it produces the following slow-ticking output: 1 Interpreting such tests without color can be somewhat challenging 2. Fast tests Now let’s test something ridiculous, such as waiting for a hundred days using Spock. Luckily, RxJava & RxGroovy also do implement the test scheduler, thus enabling fast tests using virtual time: import spock.lang.Specification import rx.Observable import rx.schedulers.TestScheduler import java.util.concurrent.TimeUnit class DontWaitForever extends Specification { def "why wait?"() { setup: def scheduler = new TestScheduler() // system under test: will tick once after a hundred days def observable = Observable.just(1).delay(100, TimeUnit.DAYS, scheduler) def done = false when: observable.subscribe { done = true } // still in the initial state done == false and: scheduler.advanceTimeBy 100, TimeUnit.DAYS then: done == true } } 3 just checking, advancing the time by 99 days results in a failure: Delightful, groovy colors! Source github.com/d-led/dont_wait_forever_for_the_tests Caputured with the wonderful pragmatic tool LICEcap by the Reaper developers ? Here, the ‘still waiting’ subscription is terminated after the first subscription ends. Try exchanging the order of the subscribe calls. ? Building using Gradle ? This entry was posted in DLed, Groovy, Programming and tagged dip, groovy, hello world, jvm, ood, oop, pragmatic, reactive extensions, rxgroovy, rxjava, scheduler, SDP, SOLID, test, testing, virtual time on November 7, 2015 by DLed. Deterministic Testing of Concurrent Behavior in RxCpp Leave a reply A Retrospective After getting inspired by The Reactive Manifesto, it is hard not to get excited about Reactive Extensions. Such excitement has lead to a series of hello-world articles and some code examples. While Reactive Extensions take over the programming world in C#, Java and JavaScript, it seems, the world of C++ is slow to adopt RxCpp. The new ReactiveX Tutorial link list is a great place to start learning and grokking. This article is an attempt to bring RxCpp closer to C++ developers who might not see yet, how a reactive programming model might help writing better, more robust code. Testing concurrency with RxCpp A previous article showed how to test ViewModels in C# by parameterizing the ViewModels with a scheduler. In a UI setting, the scheduler usually involves some kind of synchronization with the GUI thread. Testing keystrokes arriving at certain speed would require some effort to simulate events, probably leading to brittle tests. With the scheduler abstraction, the concurrent behavior of a component is decoupled from physical time, and thus can be tested repeatedly and very fast. This was the C# test: (new TestScheduler()).With(scheduler => { var ticker = new BackgroundTicker(scheduler); int count = 0; ticker.Ticker.Subscribe(_ => count++); count.Should().Be(0); // full control of the time without waiting for 1 second scheduler.AdvanceByMs(1000); count.Should().Be(1); }); Show Me The Code Without further ado, the C++ version is not very far from the C# version. In a simple test, we can parameterize a sequence of integer values arriving at specified intervals (a ticker) with a coordination (why coordination and not scheduler, read in the RxCpp developer manual: auto seq = rxcpp::observable::interval( std::chrono::milliseconds(1), some_scheduler ); The deterministic test scheduler API is currently available through a worker created on the test scheduler: auto sc = rxcpp::schedulers::make_test(); auto worker = sc.create_worker(); auto test = rxcpp::identity_same_worker(worker); The rest should read like English: int count = 0; WHEN("one subscribes to an observable sequence on the scheduler") { auto seq = rxcpp::observable::interval( std::chrono::milliseconds(1), test // on the test scheduler ).filter([](int i) { return i % 2; }); seq.subscribe([&count](int){ count++; }); THEN("the sequence is not run at first") { worker.sleep(2 /* ms */); CHECK(count == 0); AND_WHEN("the test scheduler is advanced manually") { THEN("the sequence is run as expected") { worker.advance_by(8 /* ms */); CHECK(count == 5); } } } } The full test can be seen @github, and is built on Travis CI This entry was posted in C++, DLed, Programming and tagged C++, catch, ci, concurrency, cpp, hello world, nuget, ppl, reactive, reactive extensions, reactiveextensions, reactivemanifesto, rx.cpp, rxcpp, show me the code, software quality, testing, virtual time, visual studio on August 5, 2015 by DLed. null Leave a reply This entry was posted in Daily Photo, DLed, Photography and tagged concurrent vision, DLed, null, photo on May 25, 2015 by DLed. RxCpp 2 Leave a reply Contents 1 RxCpp 2 and API 2 Still Ticking: Scheduler and Coordination in RxCpp 2 3 Why didn’t it tick? 4 Tick and Stop RxCpp 2 and API The last article on rxcpp was based on a now obsolete version of RxCpp. The key contributor to the library, Kirk Shoop, has kindly provided a rewrite based on the newer, 2.0 API of the library: see the pull request, upon which this article is based. Since the first article, the project has been enriched with somewhat more readable GIVEN/WHEN/THEN-style tests using Catch 1. Still Ticking: Scheduler and Coordination in RxCpp 2 The previous articles give examples of managing periodic events, such as ticker ticks and measurements in c++. The following example creates an event loop that will be used for coordinated output of various events to the console: auto scheduler = rxcpp::schedulers::make_same_worker( rxcpp::schedulers::make_event_loop().create_worker() ); auto coordination = rxcpp::identity_one_worker(scheduler); One such sequence of events is some kind of measurement 2 auto measure = rxcpp::observable::interval( // when to start scheduler.now() + std::chrono::milliseconds(250), // measurement frequency std::chrono::milliseconds(250), coordination) // take Hz values instead of a counter .map([&FM](int) { return FM.Hz(); }); auto measure_subscription = measure .subscribe([](int val) { std::cout pending(2); ... // after all subscriptions defined while (pending) { sleep(1000); // wait for ticker and measure to finish } Tick and Stop The other ticker will have another period, will only tick 10 times, and then decrement the pending counter: auto ticker = rxcpp::observable::interval( scheduler.now() + std::chrono::milliseconds(500), std::chrono::milliseconds(500), coordination); ticker .take(10) .subscribe([](int val) { std::cout 0 ) assert.True( #config.some.other.url > 0 ) end) end) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 describe("automatic lua properties",function() it ("should be clear from an example",function() local autoprop = require 'autoprop' -- an empty table upon creation -- local config = autoprop() assert.True( #config == 0 ) -- properties are added dynamically on demand -- config.some.url = 'http://olivinelabs.com/busted' config.some.number = 42 config.some.other.url = 'https://github.com/nrother/dynamiclua' -- this should hold -- assert.are_equal(42, config.some.number) assert.True( #config.some.url > 0 ) assert.True( #config.some.other.url > 0 ) end) end) Here is a little exercise in Lua metaprogramming. Code https://github.com/d-led/automatic-lua-property-tables Spec: autoprop_spec.lua Implementation: autoprop.lua P.S. Other implementations: lua-users wiki: Automagic Tables This entry was posted in DLed, Lua, Programming and tagged automagic, automatic table properties, autovivication, busted, config, example, exercise, Lua, metaprogramming, metatable, method missing, setmetatable, specification, table on March 29, 2015 by DLed. Presenting at TU-Munich: testing on c++ projects, Thursday, March 26, 2015 7:00 PM Leave a reply Expecting Thank you to all for a superb heated debate! next week “no excuses for not testing on c++ projects” Thursday, March 26, 2015 7:00 PM details: http://www.meetup.com/MUCplusplus/events/220628575/ If only all test were comprehensible… SCENARIO("acquiring wisdom") { GIVEN("an oracle") { oracle gus; WHEN("I ask it to speak") { auto answer = gus.speak(); THEN("wisdom is apparent") { CHECK( answer != "bla" ); } } } } 1 → The code can be found @github, including the presentation slides. Catch ? This entry was posted in C++, Programming and tagged bdd, c#, catch, cucumber, cucumber-cpp, gherkin, googlemock, hayai, meetup, munich, premake, presentation, simplify, tdd, testing, TUM on March 19, 2015 by DLed. Итого: 2014 / Balance: 2014 Leave a reply Oscar Beltran Rosalia Wanka & Tamara Kronheim 2014 – A year of London and a fast pace. → 2013 This entry was posted in DLed, Photography, Review and tagged 2013, DLed, London, photo, review, Rosalia Wanka, year, итого on December 31, 2014 by DLed. Post navigation ← Older posts Search Search for: Categories Archive (9) DLed (128) Music (16) Notes (1) Photography (58) Books (1) Daily Photo (24) Exhibitions (3) Products (1) Review (4) Travel (5) Programming (48) c# (9) C++ (34) Groovy (1) Lua (17) Thoughts (3) Video (1) Web (5) Friends (2) News (5) Uncategorized (1) Tags abstract background worker bass black&white c# C++ catch concurrency cpp csharp daily photo dependency injection DLed exhibition github Guitar hello world humor improvisation library London loop Lua LuaBridge mp3 music photo photography ppl premake programming reactive reactive extensions responsive review Rosalia Wanka rx show me the code simple tango testing tutorial ui Windows Forms WinForms Recent Posts A unit test suite is a spiderweb Итого: 2015 / Balance: 2015 Why wait forever for the tests? Fast tests of slow software. Deterministic Testing of Concurrent Behavior in RxCpp null RSS RSS - Posts RSS - Comments Proudly powered by WordPress

ledentsov.de Whois