title: JavaScript: czy stałe maszyny mają zastosowanie?

text: Piszę podprogramy numeryczne dla studentów nauk ścisłych i inżynieryjnych (chociaż są one swobodnie dostępne dla każdego innego) i zastanawiam się, jak prawidłowo używać stałych maszynowych w programie JavaScript lub czy są one w ogóle możliwe do zastosowania. Na przykład, powiedzmy, że piszę program w C++, który numerycznie oblicza pierwiastki następującego równania: exp(-0,7x) + sin(3x) - 1,2x + 0,3546 = 0 Procedura znajdowania pierwiastków powinna być w stanie obliczyć pierwiastki do wnętrza maszyny epsilon. W C++ wartość tę określa język: DBL_EPSILON. C++ określa również najmniejszą i największą wartość, która może być przechowywana przez zmienną typu float lub double. Jednak w jaki sposób konwertuje się to na JavaScript? Ponieważ program JavaScript działa w przeglądarce internetowej i nie wiem, na jakim komputerze będzie go uruchamiał, a JavaScript nie ma odpowiednich predefiniowanych wartości dla tych wielkości, jak mogę zaimplementować własną wersję tych stałych, aby moje programy obliczają wyniki z taką dokładnością, jaka jest dozwolona na komputerze z uruchomioną przeglądarką internetową? Mój pierwszy projekt to po prostu skopiowanie stałych literalnych z C++: FLT_MIN: 1.17549435082229e-038 FLT_MAX: 3.40282346638529e+038 DBL_EPSILON: 2.2204460492503131e-16. na którym uruchomiony jest program. W ten sposób superkomputer może obliczać wyniki z większą dokładnością niż stary, niskopoziomowy komputer osobisty. ALE nie wiem, czy taka procedura rzeczywiście dotarłaby do komputera, w takim przypadku marnowałbym swój czas. Czy ktoś tutaj wie, jak obliczać i używać (w JavaScript) wartości, które odpowiadają stałym maszynowym w skompilowanym języku? Czy warto poświęcić swój czas na pisanie małych programów w JavaScript, które obliczają DBL_EPSILON, FLT_MIN, FLT_MIN itp. do użytku w procedurach numerycznych? A może lepiej po prostu przypiszę stałe dosłowne, które pochodzą bezpośrednio z C++ na standardowym komputerze z systemem Windows?


title: Czy menedżerowie zatrudniający mają trudności z zaakceptowaniem programistów, którzy mają osobistą aplikację „podobną do firmy”, ale NIE są przedsiębiorcami?

text: Bezpośrednio po ukończeniu studiów postanowiłem zbudować własną aplikację internetową (Ułatwiaj mój dzień), czekając na pracę jako inżynier oprogramowania. Powody, dla których warto zbudować tę aplikację: * Zdobądź solidne doświadczenie w oprogramowaniu, zanim wejdziesz na scenę pracy * Zapewnienie rozwiązania typowego problemu * **Nie siedzenie i nicnierobienie** podczas szukania pracy Aplikacja **Nie** jest przedsiębiorcza próba ani firma do sprzedania. Wciąż podczas wywiadów zauważyłem, że 4 na każde 5 wywiadów, które przechodzę przez aplikację, jest mylone z **biznesem** i zadają mi te same pytania: > Dlaczego zbudowałeś biznes? Dlaczego chcesz **zatrzymać** aplikację? Czy chcesz > sprzedać aplikację? Wiedząc, że nie zbudowałem firmy ani nie osiągnąłem żadnych dochodów z tej aplikacji. Czy kandydaci, którzy podejmują inicjatywy i lubią tworzyć własne aplikacje na boku, powodują **czerwoną flagę** na radarze menedżera ds. rekrutacji? # UPDATE zlecona przez @Kate Gregory Oto jak opisuję to w moim CV: > Projekt osobisty: Twórca aplikacji SaaS „Ease My Day”, Montreal, Qc. > Link: http://www.easemyday.com > Facebook: http://www.facebook.com/EaseMyDay > > „Ułatw mój dzień” Głównym celem BETA jest pomoc w codziennym żywieniu/zdrowiu > monitorowanie. > > _Dostępna jest lista ponad 6000 produktów spożywczych wraz z ich wartościami odżywczymi. > Użytkownicy mogą dodawać własne produkty spożywcze i rozbudowywać bazę danych żywności. > Pozwala użytkownikom określić swój cel: schudnąć, przytyć, brak celu > po prostu pozostać zdrowym. > Pozwala użytkownikom obliczyć dzienne zapotrzebowanie (kalorie, białko, > węglowodany, tłuszcze itp.) za pomocą wbudowanego w aplikację kalkulatora. Użytkownicy mogą > ręcznie wprowadzić te wartości, jeśli już znają swoje potrzeby. > Użytkownicy mogą monitorować spożycie żywności według: posiłków, dni i/lub tygodni. > Jest wdrożony na Amazon AWS (instancja EC2 z RDS) _ > > > „Ułatwiaj mój dzień” rozwiązał zniechęcające zadanie; jest to wydajna pod względem szybkości platforma, która > zamienia codzienne monitorowanie stanu zdrowia – w przeszłości szczególnie czasochłonne zadanie – > w przyjemną czynność, którą można sfinalizować w zaledwie kilka sekund. Jest > obecnie używany w kilku krajach na całym świecie. > > Języki/technologia: **_.... TUTAJ wyjaśniam > używane języki/technologie/podejścia Inżynierii Oprogramowania...._**


title: co oznacza poniższa definicja?

text: Jestem nowy w javascript i zacząłem uczyć się ze strony w3schools. Nie jestem w stanie zrozumieć, co oznacza poniższy wiersz. Czy ktoś może to wyjaśnić na przykładzie? > Możesz używać tylko document.write w danych wyjściowych HTML. Jeśli użyjesz go po załadowaniu > dokumentu (np. w funkcji), cały dokument zostanie > nadpisany.


title: Automatyczne rozwiązywanie konfliktów spotkań

text: Próbuję wymyślić algorytm ustalania terminów spotkań. Obecnie mam naiwny algorytm, który wielokrotnie przesuwa sprzeczne spotkania, dopóki nie będzie więcej spotkań. # Lista spotkań jest zawsze sortowana według godziny rozpoczęcia lista_spotkań = [ <Spotkanie: 10:00 -> 12:00>, <Spotkanie: 11:00 -> 12:30>, <Spotkanie: 13:00 -> 14:00 >, <Spotkanie: 13:30 -> 14:30>, ] Ograniczeniem jest to, że terminy: * nie mogą odbyć się po 15:00 * nie mogą odbyć się przed 9:00. for possible_conflict in meet_list[i+1:]: if possible_conflict.start < app.end: różnica = app.end - possible_conflict.start possible_conflict.end += różnica possible_conflict.start += różnicy else: break Daje to następujące rozwiązanie , co oczywiście przełamuje te ograniczenia, a ostatnie spotkanie będzie musiało zostać przesunięte na następny dzień. Lista_spotkań = [ <Spotkanie: 10:00 -> 12:00>, <Spotkanie: 12:00 -> 13:30>, <Spotkanie: 13:30 -> 14:30>, <Spotkanie: 14:30 -> 15:30>, ] Oczywiście jest to nieoptymalne, wykonuje 3 ruchy spotkań, podczas gdy konflikt można było rozwiązać jednym: gdybyśmy byli w stanie przesunąć pierwsze spotkanie do tyłu, moglibyśmy uniknąć przesuwania wszystkich kolejnych spotkań w dół. Myślę, że powinno istnieć podejście do edycji odległości, które obliczyłoby ** najmniejszą liczbę spotkań, które należy przenieść, aby rozwiązać konflikt w harmonogramie** , ale nie mogę zrozumieć metodologia. Czy powinno to być poszukiwanie rozwiązania najpierw wszerz, czy w głąb. Kiedy dowiem się, czy rozwiązanie jest „wystarczająco dobre”?


title: Jaka jest różnica między infrastrukturami e-nauki a infrastrukturami przetwarzania rozproszonego?

text: Jaka jest różnica między infrastrukturami eScience a przetwarzaniem siatkowym lub rozproszonymi infrastrukturami obliczeniowymi? A jakie są niektóre z ich przykładów. Nie potrafię ich wyraźnie odróżnić. Czy to, w jaki sposób wykorzystywana jest siatka, czyni z niej platformę e-naukową?


title: Zmiana zachowania klasy abstrakcyjnej bez modyfikowania podklas

text: Mam problem ze zmianą zachowania biblioteki (w związku z tym nie mogę lub nie chcę zmieniać jej wnętrza ze względu na przyszłe aktualizacje itp.). W tej bibliotece znajduje się klasa abstrakcyjna, która dzieli kilka metod ze wszystkimi swoimi podklasami. Teraz muszę zmienić kilka metod w tej abstrakcyjnej super klasie bez zmiany podklas. Zastanawiałem się, jaki wzór powinienem zastosować do tego bez przepisywania całości. Używam PHP, więc mógłbym użyć cechy do zastąpienia tych metod w moich własnych podklasach, które następnie użyję w kodzie mojego klienta. Spowodowałoby to utworzenie podklas i dodanie cechy (która jest jednowierszowa). Ale muszę uruchomić PHP 5.3, który nie obsługuje cech. Czy istnieje wzór, który rozwiązuje ten problem? EDYCJA 2: chodzi o to, że nie chcę zmieniać kodu biblioteki, mogę rozszerzyć podklasy i wykorzystać je w kodzie klienta, ale nie chcę zmieniać kodu w samej bibliotece (dzięki czemu mogę łatwo zaktualizować bibliotekę ). EDYCJA: zobacz uproszczony kod poniżej Klasa abstrakcyjna SuperClass { funkcja chroniona doMagic() {... Muszę to zmienić... } abstrakcyjna funkcja publiczna execute(); } class SubClass1 extends SuperClass { protected public execute() { $this->doMagic(); ... jakiś inny kod ... } } class SubClass2 extends SuperClass { protected public execute() { $this->doMagic(); ... inny kod ... } }


title: Czy użycie „utf8=✓” jest lepsze niż „utf8=prawda”?

text: Ostatnio widziałem kilka identyfikatorów URI zawierających parametr zapytania „utf8=✓”. Moje pierwsze wrażenie (po pomyśleniu „mmm, wygląda fajnie”) było takie, że można to wykorzystać do wykrycia nieprawidłowego kodowania znaków. Czy jest to więc lepszy sposób na rozwiązanie potencjalnych problemów z kodowaniem znaków, czy to tylko programista bawiący się hackiem?


title: JavaScript, programowanie funkcjonalne i przetwarzanie równoległe

text: Kiedy używam biblioteki jquery, zauważam, że kod będzie kontynuował wykonywanie, niezależnie od tego, czy poprzednia linia zakończyła wykonanie. Dokładniej, używając jquery ajax, będzie kontynuował wykonywanie bez czekania na wynik ajax. Czy to dlatego, że JavaScript korzysta z przetwarzania równoległego? Lub do jakiej kategorii można to odnieść. Czy możemy również nazwać javascript jako funkcjonalny język programowania.? Będzie bardzo mile widziane, gdyby ktoś mógł to krótko wyjaśnić. Z góry dziękuję.


title: Jakie są praktyczne sposoby wdrożenia SRP?

text: Po prostu jakich praktycznych technik używają ludzie, aby sprawdzić, czy klasa narusza zasadę pojedynczej odpowiedzialności? Wiem, że klasa powinna mieć tylko jeden powód do zmiany, ale w tym zdaniu brakuje praktycznego sposobu, aby to naprawdę zaimplementować. Jedynym sposobem, jaki znalazłem, jest użycie zdania **_"The ......... powinien sam .........."_**, gdzie pierwsza spacja to nazwa klasy, a później jest nazwa metody (odpowiedzialności). Czasami jednak trudno jest ustalić, czy odpowiedzialność rzeczywiście narusza SRP. Czy jest więcej sposobów sprawdzenia SRP? **Uwaga:** Nie chodzi o to, co oznacza SRP, ale o praktyczną metodologię lub serię kroków sprawdzających i wdrażających SRP. **UPDATE** ![Zgłoś klasę](http://i.stack.imgur.com/D8u6h.png) Dodałem przykładową klasę, która wyraźnie narusza SRP. Byłoby wspaniale, gdyby ludzie mogli użyć go jako przykładu do wyjaśnienia, w jaki sposób podchodzą do zasady pojedynczej odpowiedzialności. Przykład pochodzi stąd.


title: Zalecana metodologia pracy z bibliotekami współdzielonymi i Mercurial

text: Pracuję w małym zespole programistów, którzy współpracują przy kilku projektach Zend PHP. Używamy Mercurial z kolekcją repozytoriów upstream, a także Jenkins do scentralizowanych testów i raportów o stanie zdrowia. Chcemy zaimplementować współdzieloną bibliotekę wspólnych klas, ale walczymy ze znalezieniem przepływu pracy, który dobrze współpracuje z naszym obecnym środowiskiem. Obecnie każdy projekt zawiera taką strukturę: - aplikacja (kod specyficzny dla projektu) - build (pliki tymczasowe generowane przez każdy build) - biblioteka (kod używany przez wiele projektów) - OurLibrary (wspólna baza kodów naszej firmy) - Zend (biblioteki zewnętrzne) - testy (kod testowy specyficzny dla tego projektu) Folder biblioteki jest wykluczony z testowania, dlatego stworzyliśmy projekt specjalnie do uruchamiania testów jednostkowych względem biblioteki współdzielonej. Ta decyzja została podjęta przede wszystkim po to, aby uniknąć przypadkowego wdrożenia klas testowych, co w dużej mierze można złagodzić przez modyfikację zautomatyzowanego procesu budowania, ale także dlatego, że uznaliśmy, że lepiej jest zachować lekkość biblioteki. Dołączamy bibliotekę do każdego projektu jako subrepo Mercurial. Oznacza to, że zmiany wprowadzone do biblioteki przez programistę pracującego nad ProjektemA nie będą automatycznie propagowane do ProjektuB (dobre), ale także nie przejdą do projektu testującego bibliotekę (zły), a zatem Jenkins nie będzie automatycznie ostrzegał nas o potencjalnym złamaniu kodu w biblioteka (bardzo zła). Idealną sytuacją byłoby, gdyby programiści mogli wprowadzać zmiany w bibliotece z dowolnego projektu, a nasze zautomatyzowane narzędzia uruchomiłyby następnie najnowsze testy biblioteki w oparciu o najnowszy kod biblioteki. Co więcej, nie powinno to skutkować konfliktem wersji, gdy programista pobiera nową wersję testów biblioteki. Czy istnieje ustalona metodologia dla tego rodzaju przepływu pracy, czy też powinniśmy trochę inaczej zastanowić się nad strukturą naszych praktyk roboczych, zanim w pełni zobowiążemy się do subrepo?


title: Przechwytywanie odpowiedniego poziomu szczegółowości w historyjce użytkownika

text: Napisałem różne historie użytkowników, które opisują funkcjonalność na dość wysokim poziomie. Na przykład: Jako analityk chcę zobaczyć aktualną cenę akcji, aby mieć szybki dostęp do aktualnej wyceny akcji na giełdach Euronext, Londyn i Nowy Jork. To wymaganie jest oparte na istniejącej funkcjonalności, która jest ponownie rozwijana w nowej wersji oprogramowania. Widzę z istniejącej implementacji, że rzeczywiste wyświetlane informacje zawierają wiele dodatkowych danych, takich jak różne klasy lub udziały, różne skale czasowe wykresów itp. Myślę, że niepraktyczne jest uchwycenie całej funkcjonalności w obecnej implementacji. Mam więc dwa pytania: 1. Jak określić odpowiedni poziom szczegółowości wymagania, którym jest zasadniczo „zrób to, co robi bieżąca funkcja”. 2. Czy istnieje jakieś ustrukturyzowane podejście polegające na dołączeniu do historyjki użytkownika większej ilości informacji? W tej chwili czuję, że to byłaby praca makiety.


title: PHP PSR-0 + kilka przestrzeni nazw w jednym pliku i automatyczne ładowanie

text: Od jakiegoś czasu zastanawiałem się nad zdefiniowaniem kilku przestrzeni nazw w jednym pliku php, a więc posiadaniem kilku klas w tym pliku. Załóżmy, że chcę zaimplementować coś takiego jak `Doctrine\ORM\Query\Expr`: Expr.php Expr |-- Andx.php |-- Base.php |-- Porównanie.php |-- Composite.php |-- From .php |-- Func.php |-- GroupBy.php |-- Join.php |-- Literal.php |-- Math.php |-- OrderBy.php |-- Orx.php `-- Select.php Byłoby miło, gdybym miał to wszystko w jednym pliku - `Expr.php`: namespace Doctrine\ORM\Query; class Wyr { // kod } przestrzeń nazw Doctrine\ORM\Query\Expr; class Func { // kod } // itd... Myślę o konwencji nazewnictwa katalogów iw przeciwieństwie do `PSR-0` posiadanie kilku klas i przestrzeni nazw w jednym pliku. Najlepiej wyjaśnia to kod: ls Doctrine/orm/query Expr.php to wszystko - tylko `Expr.php` Ponieważ `Expr.php` jest w pewnym sensie „meta-przestrzenią nazw” dla `Expr\Func`, sens, aby umieścić wszystkie klasy wewnątrz Expr.php (jak pokazano powyżej). Tak więc nazwa dostawcy nadal zaczyna się od dużej litery („Doctrine”), a pozostałe części przestrzeni nazw zaczynają się od małej litery. Możemy napisać autoload, aby respektowało to pojęcie: function load_class($class) { if (class_exists($class)) { return true; } $tokenized_path = explode(array("_", "\\"), DIRECTORY_SEPARATOR, $class); // array('Doctrine', 'orm', 'query', 'Expr', 'Func'); // ^^^^ // najpierw szukamy pierwszej części przestrzeni nazw pisanej wielkimi literami // a jeśli nie jest ona ostatnia (nie nazwa klasy), używamy jej jako nazwy pliku // i usuwamy resztę, aby utworzyć ścieżkę do plik, który musimy dołączyć if (FALSE !== ($meta_class_index = find_meta_class($tokenized_path))) { $new_tokenized_path = array_slice($tokenized_path, 0, $meta_class_index); $ścieżka_do_klasy = implode(SEPARATOR_KATALOGU, $nowa_ścieżka_tokenizowana); } else { // nie znaleziono metaklasy $path_to_class = implode(DIRECTORY_SEPARATOR, $tokenized_path); } if (file_exists($ścieżka_do_klasy.'.php')) { require_once $ścieżka_do_klasy.'.php'; } zwróć fałsz; } Innym powodem, aby to zrobić, jest zmniejszenie liczby plików php rozproszonych w katalogach. Zwykle sprawdzasz istnienie pliku, zanim zażądasz, aby plik zawiódł: file_exists($path_to_class.'.php'); Jeśli spojrzysz na rzeczywisty kod `Doctrine\ORM\Query\Expr`, zobaczysz, że używają one wszystkich "klas wewnętrznych", więc faktycznie to robisz: file_exists("/path/to/Doctrine/ORM/ Zapytanie/Wyr.php"); file_exists("/ścieżka/do/Doctrine/ORM/Query/Expr/AndX.php"); file_exists("/ścieżka/do/Doctrine/ORM/Query/Expr/Base.php"); file_exists("/ścieżka/do/Doctrine/ORM/Query/Expr/Comparison.php"); file_exists("/ścieżka/do/Doctrine/ORM/Query/Expr/Composite.php"); file_exists("/ścieżka/do/Doctrine/ORM/Query/Expr/From.php"); file_exists("/ścieżka/do/Doctrine/ORM/Query/Expr/Func.php"); file_exists("/ścieżka/do/Doctrine/ORM/Query/Expr/GroupBy.php"); file_exists("/ścieżka/do/Doctrine/ORM/Query/Expr/Join.php"); file_exists("/ścieżka/do/Doctrine/ORM/Query/Expr/Literal.php"); file_exists("/ścieżka/do/Doctrine/ORM/Query/Expr/Math.php"); file_exists("/ścieżka/do/Doctrine/ORM/Query/Expr/OrderBy.php"); file_exists("/ścieżka/do/Doctrine/ORM/Query/Expr/Orx.php"); file_exists("/ścieżka/do/Doctrine/ORM/Query/Expr/Select.php"); w twoim automatycznym ładowaniu, co powoduje sporo odczytów I/O. Czy nie jest zbyt wiele, aby sprawdzać trafienia każdego użytkownika? Po prostu poddaję to dyskusji. Chcę usłyszeć od innych programistów PHP, co o tym sądzą. I oczywiście, jeśli masz srebrną kulę dotyczącą problemów, które tutaj wymieniłem, podziel się nimi. Zastanawiałem się również, czy moje modne pytanie pasuje tutaj i zgodnie z `FAQ` wydaje się, że to pytanie dotyczy propozycji _slash_ problemu "architektury oprogramowania". Przepraszam, jeśli moje bazgroły mogą wydawać się trochę niezgrabne :) Dzięki.


title: Analogia dla puli wątków

text: Pracuję nad aplikacją, która tworzy nowy wątek na żądanie. Czasami liczba wątków aktywnych jednocześnie na komputerze sięga setek. Podejrzewa się, że powoduje to różnego rodzaju problemy. Chciałbym zamiast tego poeksperymentować z użyciem puli wątków, aby sprawdzić, czy poprawia to przepustowość pracy. Ale najpierw muszę przekonać siły, które mają dać mi czas. Jako część mojej argumentacji, myślę, że pomogłaby dobra analogia porównująca metodę brute-force „uruchamianie x wątków” z techniką pul wątków. Czy istnieje na to podręcznikowa analogia?


title: Zmiana pamięci podręcznej frontendu

text: Nasza architektura składa się z front-endowej pamięci podręcznej, z której większość użytkowników tylko do odczytu uzyskuje swoje dane bezpośrednio. Pamięć podręczna frontonu znajduje się przed farmą serwerów internetowych, które obsługują strony napisane w PHP. Musimy być w stanie wykryć pewne warunki na poziomie pamięci podręcznej front-endu i przekazać te wartości do back-endu za pomocą nagłówków HTTP. Na przykład chcielibyśmy ręcznie otagować sieć operatora na podstawie adresu IP. Tak więc w przypadku ruchu przychodzącego, jeśli użytkownik mówi, że pochodzi z adresu IP z zakresu „41.202.192.0”/19 oznaczymy go jako użytkownika Orange Cameroon, ustawiając odpowiedni nagłówek żądania HTTP, np. X-Carrier = „Pomarańczowy Kamerun”. W oparciu o ustawienie tego nagłówka chcielibyśmy zmieniać pamięć podręczną i wyświetlać użytkownikowi końcowemu inny baner. Jak byś się do tego zabrał? Pamiętaj, że nie chcemy zanieczyszczać pamięci podręcznej i nie chcemy też tworzyć zbyt wielu małych segmentów pamięci podręcznej. Założenia: Możesz założyć, że X-Carrier został już wykryty w naszej pamięci podręcznej. Tak więc na potrzeby testu możesz po prostu ustawić tę wartość ręcznie w przykładowym skrypcie.


title: Jaka jest różnica między historyjkami użytkownika a funkcjami?

text: Bawiąc się icecrum, zdałem sobie sprawę, że nie rozumiem różnicy między historyjkami użytkownika a funkcjami użytkownika. Czy ktoś może wyjaśnić różnicę?


title: Skuteczny sposób na oszacowanie usunięcia martwego kodu?

text: Pracowałem w aplikacji z około 100 000 LOC i zasadniczo przerabialiśmy funkcje, aby były zgodne z nową architekturą opartą na nowym stosie technologicznym. Ta praca jest prawie zakończona, ale musieliśmy zachować stary kod, ponieważ w nowym musieliśmy zagwarantować stabilne środowisko na wypadek krytycznych błędów. Doprowadziło to do sytuacji, w której mamy dużo martwego kodu, który miesza się z dużą ilością działającego kodu, co utrudnia oszacowanie, ile czasu zajęłoby usunięcie tego martwego kodu. Szczególnie ta baza kodu jest bardzo kłopotliwa, ponieważ nie ma testów jednostkowych/integracyjnych innych niż te wygenerowane w procesie przerabiania funkcji, które przenieśliśmy do nowej architektury, a także myślę, że duża część nowego kodu jest spleciona z martwy kod (przez wywołania statyczne, przy użyciu wcześniej zgłoszonych wyjątków). Jaki byłby dobry punkt wyjścia do oszacowania, ile czasu zajmie bezpieczne usunięcie kodu?


title: Jak ogólnie realizowany jest okres próbny oprogramowania?

text: Zawsze wyszedłem z założenia, że oprogramowanie testowe zapisuje w rejestrze wartość daty instalacji, a następnie oprogramowanie dokonuje porównania aktualnej daty systemu z pozostałymi dniami + data instalacji, aby zweryfikować, czy okres testowy jest nadal ważny, czy nie. Jeśli to założenie ma być prawdziwe, cofnięcie zegara systemowego dalej niż pozostałe dni powinno zakończyć okres próbny oprogramowania (lub cofać zegar do tyłu, aby korzystać z oprogramowania próbnego tak długo, jak chcesz). Z doświadczenia wynika, że tak było w przypadku niektórych programów, a nie w przypadku innych. W tym drugim przypadku zauważyłem, że okres próbny wygasa dopiero po upływie dni w czasie rzeczywistym. Potwierdziłem, że oprogramowanie nie łączyło się z siecią zewnętrzną w celu mechanizmu walidacji, więc zdecydowanie jest to coś, co dzieje się lokalnie na komputerze. **Jak działa w tym przypadku walidacja okresu próbnego?**


title: Złożoność aplikacji internetowej

text: Obecnie piszę pracę magisterską na temat pielęgnowalności aplikacji webowej. Znalazłem kilka metod, takich jak „Indeks trwałości” autorstwa Colemana i in. lub „Indeks Utrzymania Oprogramowania” Muthanna et.al. Dla obu trzeba obliczyć złożoność cyklomatyczną. Więc moje pytanie brzmi: czy można zmierzyć cyklomatyczną złożoność aplikacji internetowej? Moim zdaniem aplikacja internetowa składa się z trzech części: 1. Kod serwera (PHP, C#, Python, Perl, itp.) 2. Kod klienta (JavaScript) 3. HTML (linki i formularze jako operatory, parametry GET i formularz pola jako operandy!?) Co o tym myślisz? Czy istnieje inny punkt widzenia na złożoność aplikacji internetowej? Przegapiłem coś?


title: co przyniesie nam EcmaScript 6

text: Nasza firma przeniosła umiarkowane fragmenty logiki biznesowej do JavaScript. Kompilujemy kod z minifikatorem, co dodatkowo poprawia wydajność. Ponieważ język jest dynamicznie typowany, dobrze nadaje się do zaciemniania, które występuje jako produkt uboczny minifikacji. Dołożyliśmy wszelkich starań, aby to pozytywnie krzyczało, jeśli chodzi o wydajność. Możemy teraz robić to, co robiliśmy wcześniej, szybciej, lepiej, z mniejszą ilością kodu i na większej liczbie platform. **Podsumowując, jesteśmy bardzo zadowoleni z obecnego stanu języka.** Osobiście uwielbiam ten język, szczególnie za jego wieloplatformowy charakter. Więc naturalnie dużo czytam o stanie kompilatorów JavaScript, wydajności i kompatybilności w tylu przeglądarkach i platformach, ile mam czasu na zbadanie. Jedynym tematem, który staje się ostatnio coraz głośniejszy, są wiadomości o ECMAScript 6. Do tej pory udało mi się zebrać, że ES6 obiecuje lepsze wrażenia programistyczne; po pierwsze poprzez udostępnienie nowych sposobów robienia rzeczy, po drugie poprzez wczesne zgłaszanie błędów. Brzmi to świetnie dla tych, którzy wciąż czekają, aż język spełni ich potrzeby, zanim wskoczą na pokład. Ale wskoczyliśmy już na pokład w wielkim stylu. Jasne, spodziewam się, że przez lata będziemy musieli dokonywać ciągłej konserwacji i poprawek funkcji w naszym kodzie, i że oczywiście będziemy korzystać z najlepszych praktyk w tamtym czasie. Ale nie widzę, abyśmy refaktoryzowali główne jego części, aby skorzystać z funkcji językowych, które mają głównie na celu zwiększenie produktywności programistów. Ciągle się zastanawiam, jaki wpływ ostatecznie rozwój języka będzie miał na naszą **istniejącą**, dobrze napisaną, dobrze działającą bazę kodu? Czy czegoś mi brakuje? Czy jest coś, na co powinniśmy zwrócić uwagę? Czy ktoś ma wskazówki lub wskazówki, jak powinniśmy podejść do finalizacji ecmascript.next? Czy powinno nas to obchodzić?


title: W jaki sposób interfejs API powinien korzystać z podstawowego uwierzytelniania http?

text: Gdy interfejs API wymaga, aby klient się do niego uwierzytelnił, widziałem dwa różne scenariusze i zastanawiam się, którego przypadku powinienem użyć w mojej sytuacji. Przykład 1. API jest oferowane przez firmę, aby umożliwić stronom trzecim uwierzytelnianie za pomocą tokena i klucza tajnego przy użyciu protokołu HTTP Basic. Przykład 2. Interfejs API akceptuje nazwę użytkownika i hasło za pośrednictwem protokołu HTTP Basic w celu uwierzytelnienia użytkownika końcowego. Zazwyczaj otrzymują zwrot tokena na przyszłe żądania. Moja konfiguracja: Będę miał interfejs API JSON, którego używam jako zaplecza dla aplikacji mobilnej i internetowej. Wydaje się, że dobrą praktyką zarówno dla aplikacji mobilnej, jak i internetowej jest wysyłanie tokenu i klucza tajnego, aby tylko te dwie aplikacje miały dostęp do interfejsu API blokującego jakąkolwiek inną stronę trzecią. Ale aplikacja mobilna i internetowa pozwala użytkownikom logować się i przesyłać posty, przeglądać swoje dane itp. Chciałbym, aby logowali się również przez HTTP Basic przy każdym żądaniu. Czy w jakiś sposób używam kombinacji obu tych metod, czy wysyłam tylko poświadczenia użytkownika końcowego (nazwę użytkownika i token) przy każdym żądaniu? Jeśli wysyłam tylko dane uwierzytelniające użytkownika końcowego, czy przechowuję je w pliku cookie na kliencie?


title: W jaki sposób uwzględniasz wymagania dotyczące użyteczności i użytkowników dla swojej aplikacji?

text: Nasz zespół wspiera aplikację BackOffice: mieszankę okien WinForm i WPF. (około 80, w tym dialogi). Naprawdę rodzaj szwajcarskiego scyzoryka. Jest używany przez programistów, pisarzy technicznych, programistów bezpieczeństwa, testerów. Wymagania dotyczące nowych funkcji pojawiają się dość często i czasami gramy w Wizard of Oz, aby zdecydować, który GUI nasi użytkownicy lubią najbardziej. I zwykle się zdarza (przyznaję, że może to być tylko moja subiektywna interpretacja rzeczywistości), że jeden drobny szczegół nadający posmak dobrej użyteczności naszej aplikacji wymaga dużo czasu. Ten czas spędzamy na „walce” z frameworkiem GUI, aby działał tak, jak potrzebujemy. I bardzo trudno jest dokonywać szacunków dla tego typu zadań (przynajmniej dla mnie i większości członków naszego zespołu). Poker Scrum też nie jest pomocny. Kierownictwo często uważa ten perfekcjonizm użyteczności za stratę czasu. Z drugiej strony skumulowany wpływ funkcji, z których każda ma niewielką wadę użyteczności, frustruje użytkowników. Ale ci sami użytkownicy chcą częstych wydań i natychmiastowych poprawek błędów. Dlatego nie ma sposobu na uzyskanie pozytywnej opinii: zawsze jest ktoś, kto jest zaciągnięty. Ciągle czuję, że konkuruję ze sobą: więcej funkcji -> więcej błędów/zadań/architektury. Staramy się wyprzedzić wózek, który pchamy. Pojawiają się nowe technologie, a niektóre z nich mogą potencjalnie pomóc ulepszyć projekt lub skrócić czas realizacji zadań, ale technologie te wymagają uczenia się, tworzenia prototypów i tak dalej. Cóż, to była historia. A teraz pojawia się pytanie: * Jak pogodzić presję czasu, jakość produktu, użytkowników i satysfakcję kierownictwa? * Kiedy i jak decydujesz się pozostawić problem bez idealnego, ale do pewnego stopnia akceptowalnego rozwiązania, jak często podejmujesz te decyzje? * Jak sobie radzisz z własną satysfakcją? Jakie są twoje priorytety? PS Pamiętaj, że jesteśmy zespołem BackOffice, nie mamy ani dedykowanego pisarza technicznego, ani projektanta GUI. Tester dołączył do nas niedawno. Przed nami dużo pracy i dużo swobody w kwestii „jak”. Podoba mi się, bo sprzyja kreatywności, ale nie chcę być zbyt nerdowskim perfekcjonistą.


title: Czy powinienem zaimplementować BackBone.js do moich aplikacji ASP.NET WebForms?

text: # Tło Próbuję ulepszyć obecny wzorzec tworzenia aplikacji internetowych mojej grupy. Nasz obecny wzorzec jest czymś, co wymyśliliśmy, próbując rozbudować aplikacje internetowe na ASP.NET WebForms (nikt z nas nie znał ASP.NET MVC). To jest obecny wzorzec: ![schemat naszego wzorca](http://i.stack.imgur.com/GjKmw.png)! * Nasza aplikacja korzysta z platformy WinForms. * Nasze strony ASPX są w zasadzie tylko HTML, prawie nie używamy WebControls. * Używamy JavaScript/jQuery do wykonywania wszystkich naszych zdarzeń interfejsu użytkownika i wywołań AJAX. * Dla pojedynczej strony ASPX mamy jeden plik .js. * Wszystkie nasze wywołania AJAX są POST (wcale nie RESTful) * Nasze wywołania AJAX kontaktują się z WebMethods, które zdefiniowaliśmy w serii plików ASMX. * Jeden plik ASMX na obiekt biznesowy. # Dlaczego zmieniać? Chciałbym nieco zmienić nasz wzorzec z kilku powodów: 1. Zaczynamy odkrywać, że nasze pliki JavaScript stają się trochę nieporęczne. 2. Używamy mieszanki metod do utrzymywania synchronizacji lokalnych danych i aktualizacji DOM. Wydaje się, że spędzamy zbyt dużo czasu na pisaniu kodu, aby zachować synchronizację, a debugowanie może być trudne. Czytałem Developing Backbone.js Applications i podoba mi się wiele z tego, co Backbone ma do zaoferowania w zakresie organizacji kodu i separacji obaw. Jednak dotarłem do rozdziału o aplikacji RESTful, zacząłem się wahać przed użyciem Backbone. # Problem Problem polega na tym, że nasze WebMethods tak naprawdę nie pasują do wzorca RESTful, co wydaje się być sposobem, w jaki Backbone chce je konsumować. Na razie chciałbym tylko zająć się problemem zdezorganizowanego kodu po stronie klienta. Chciałbym uniknąć poważnych przeróbek naszych WebMethods. # Moje pytania Czy możliwe jest użycie Backbone (lub podobnej biblioteki) do oczyszczenia naszego kodu klienta, bez większego wpływu na nasze WebMethods dostępu do danych? A może próba użycia Backbone w ten sposób byłaby zepsuciem jego zamierzonego zastosowania? Czy ktoś ma jakieś sugestie, jak ulepszyć nasz wzorzec w obszarze organizacji kodu i poświęcić mniej czasu na pisanie DOM i kodu synchronizacji danych?


title: Uzyskaj odwołanie do obiektu nadrzędnego podczas tworzenia instancji

text: Mam sytuację, w której klasa niestandardowa jest właściwością innej klasy. To, co muszę zrobić, jeśli w ogóle jest to możliwe, to uzyskać odwrotność do klasy "rodzica" (tj. klasy, która posiada obecną klasę jako właściwość). ### Na przykład: Public Class Class1 ... public readonly właściwość Prop11 as Class2 public property Prop12 as String ... End Class Public Class Class2 ... private _par as Class1 private _var21 as string ... Public Sub New(. ..) ja._par = ???? ... End Sub public readonly property Prop21 as string Get return me._par.Prop12 & me._var21 End Get End Property ... End Class Ostatecznie próbuję uzyskać dostęp do innych właściwości w ramach `Class1` z `Class2`, ponieważ są one mają treść dla informacji z klasy „Class2”. Istnieje kilka innych klas w ramach klasy „Class1”, które dostarczają informacji opisowych do innych klas zawartych w niej jako właściwości, ale informacje te nie są rozszerzalne na wszystkie klasy poprzez dziedziczenie, ponieważ klasa „Class1” jest używana jako pojemnik zasobów dla klas właściwości i samą aplikację. ### Diagram, leniwy projekt ;): Aplikacja <- Klasa1.Prop12 Aplikacja <- Klasa1.Prop11.Prop21 ### Pytanie: 1. Czy można uzyskać rekursję poprzez tę konfigurację projektu?


title: Wady języka SQL, Trzeci Manifest

text: Jakiś czas temu czytałem o wadach języka SQL (podstawowa specyfikacja języka, a nie konkretnego dostawcy), a jedną z wad było to, że język nie pozwala na tworzenie zestawu krotek, które nie pochodzą z tabeli. Na przykład SELECT imię, nazwisko od osób; tworzy to zestaw krotek pochodzących z tabeli „ludzie”. Teraz, jeśli nie mam tej tabeli „ludzie” i chcę zwrócić stałą, potrzebowałbym czegoś takiego, aby zwrócić zestaw dwóch krotek (nie wymagałoby to posiadania tabeli): SELECT VALUES( 'james', 'dziekan'), ('tom', 'rejs'); Dlaczego miałbym tego potrzebować? Z tych samych powodów, dla których możemy definiować stałe (nie tylko podstawowe typy, ale także obiekty i tablice) w dowolnym zaawansowanym języku programowania. Obejścia Tak, mógłbym utworzyć tabelę czasową, wypełnić dane i WYBIERZ z tej tabeli. To jest hack, aby przezwyciężyć wady słabego języka SQL. Myślę, że czytałem o tym gdzieś w „Trzecim manifeście”, ale nie znajduję już akapitu/przykładu mówiącego o tej konkretnej wadzie. Czy znasz referencję na ten temat?


title: Dlaczego w paradygmacie BDD „język wszechobecny” miałby być tylko półformalny, a nie całkowicie formalny?

text: Oto odpowiedni cytat: > Częste ryzyko związane z tworzeniem oprogramowania obejmuje awarie komunikacji > między programistami a interesariuszami biznesowymi. BDD używa specyfikacji > pożądanego zachowania jako wszechobecnego języka dla członków zespołu projektowego. To jest powód, dla którego BDD nalega na półformalny język do specyfikacji behawioralnej: pewna formalność jest wymagana, aby być językiem wszechobecnym. Ponadto posiadanie takiego wszechobecnego języka tworzy domenowy > model specyfikacji, dzięki czemu specyfikacje mogą być > rozumowane formalnie. Myślę, że prawdziwy formalny rygorystyczny „język”, który ma gramatykę i kompilator, może być przydatny, powiedzmy, do automatycznego generowania fragmentów testów ze specyfikacji lub do zagwarantowania, że specyfikacje mają pewne właściwości (spójnie nazwane rzeczownikami i czasownikami itp.). Dlaczego więc w paradygmacie BDD „wszechobecny język” miałby być tylko półformalny, a nie całkowicie formalny/rygorystyczny?


title: Wycena projektu przy rosnących wymaganiach

text: Wycena projektu z zadanymi wymaganiami to jedno. Ale co się stanie, gdy użytkownik nagle zacznie je zmieniać w locie i zacznie dodawać nowe wymagania do już zdefiniowanego zestawu? A nawet wpada w szał, dlaczego projekt nie jest ukończony w pierwotnie zaplanowanym terminie. Jak mam sobie radzić w takich sytuacjach? Pomocne może być zaproponowanie pewnych metodologii i odczytów.


title: Projektowanie oparte na testach nie jest testowaniem jednostkowym

text: Natknąłem się na to stwierdzenie Martina Fowlera około 2002 roku: > Testowanie jednostkowe w XP często różni się od klasycznego testowania jednostkowego, ponieważ w XP > zwykle nie testuje się każdej jednostki oddzielnie. Testujesz każdą klasę > i jej bezpośrednie połączenia z sąsiadami. Czy to nadal jest poprawne, a jeśli tak, to dlaczego?


title: jak wykonać operacje wektorowe na "elemencie wektorowym <string>" C++

text: Próbuję pracować nad tablicą ciągów (char **), gdzie próbuję użyć paradygmatu C++ "vector device_names". Po przeanalizowaniu ciągu wejściowego w celu dopasowania wpisów poz/ujemnych chcę posortować końcowe listy, ale próby posortowania końcowej listy wydają się myśleć, że chcę posortować znaki w jakimś elemencie listy. Kod ilustrujący to: struct ds_matches { vector <string> positive_matches; wektor <string> negatywne_dopasowania; bool include_unspecified; }; typedef struct ds_matches DS_Matches; void ds_make_matches(DS_Matches &matches, const char * match_config) { vector <string> tmp_intfs; tmp_intfs.reserve(32); int nmatches = split(tmp_intfs, match_config, " ", 32, 32); mecze.positive_matches.reserve(nmecze); mecze.negative_matches.reserve(nmecze); for (auto st:tmp_intfs) { if(st[0] == '-') { match.negative_matches.push_back((string){st,1,st.rozmiar()-1}); match.include_unspecified = 1; } else { match.positive_matches.push_back(st); match.include_unspecified = 0; } } // sortuj listy intf w celu szybszego wyszukiwania w czasie wykonywania // jeśli wyszukiwanie w czasie wykonywania jest kosztowne, może przekonwertować je na hash if (matches.negative_matches.size()>1) sort(matches.negative_matches.begin(), matches.negative_matches .end(), match.negative_matches); if (matches.positive_matches.size()>1) sort(matches.positive_matches.begin(), matches.positive_matches.end(), matches.positive_matches); } Wypróbowałem kilka permutacji składni w instrukcji sort, ale każda permutacja ma inny powód, dla którego jest niewłaściwa — wielu myśli, że próbuję posortować znaki. Linia 280 w moim kodzie (wymieniona we wszystkich komunikatach o błędach poniżej) jest kontynuacją pierwszego „sortowania”.g++: COMPILE util.cc, linux/netmeter.cc W pliku dołączonym z /usr/include/c++/4.8/algorithm:62:0, z util.cc:16: /usr/include/c++/4.8/bits/stl_algo .h: W instancji 'void std::__insertion_sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [z _RandomAccessIterator = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std,<string:::chector>> std::basic_string<znak>, std::allocator<std::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]': /usr/include/c++/4.8/bits/stl_algo.h:2250:70: wymagane od 'unieważnij std::__final_insertion_sort(_RandomAccessIterator , _RandomAccessIterator, _Compare) [z _RandomAccessIterator = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<char>*, std::__cxx1998::vector<std:::charloc_string ::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' /usr/include/c++/4.8/bits/stl_algo.h:5514:55: wymagane od 'void std::sort(_RAIter, _RAIter, _Compare) [z _RAIter = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std::alloc :basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' util.cc:280:61: wymagane stąd /usr/include/c++/4.8/bits/stl_algo.h:2183:29: błąd: brak dopasowania dla wywołania '(std::__debug::vector<std::basic_string<znak> >) (std::basic_string<znak>&, std::basic_string<znak>&)' if (__comp( *__i, *__first)) ^ /usr/include/c++/4.8/bits/stl_algo.h: W instancji 'void std::__heap_select(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator,_Porównaj) [z _RandomAccessIterator = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std:::allocator <znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]': /usr/include/c++/4.8/bits/stl_algo.h:5363:59: wymagane od 'unieważnij std::partial_sort(_RAIter , _RAIter, _RAIter, _Compare) [z _RAIter = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<char>*, std::__cxx1998::vector<std::basic_string<char> <std::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' /usr/include/c++/4.8/bits/stl_algo.h:2355:68: wymagane od 'void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [z _RandomAccessIterator = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std::allocator<std::basic_string<znak> > > >, std::__debug::vector <std::basic_string<znak> > >; _Rozmiar = długi int; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' /usr/include/c++/4.8/bits/stl_algo.h:5513:44: wymagane od 'unieważnij std::sort(_RAIter, _RAIter, _Compare) [z _RAIter = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std::alloc :basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' util.cc:280:61: wymagane stąd /usr/include/c++/4.8/bits/stl_algo.h:1972:27: błąd: brak dopasowania dla wywołania '(std::__debug::vector<std::basic_string<znak> >) (std::basic_string<znak>&, std::basic_string<znak>&)' if (__comp( *__i, *__first)) ^ /usr/include/c++/4.8/bits/stl_algo.h: W instancji 'void std::__move_median_first(_Iterator, _Iterator, _Iterator, _Porównaj) [z _Iterator = __gnu_debug::_Safe_iterator<__gnu_cxx:_string:_itear , std::__cxx1998::vector<std::basic_string<znak>, std::allocator<std::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > > ; _Porównaj = std::__debug::vector<std::basic_string<char> >]': /usr/include/c++/4.8/bits/stl_algo.h:2318:68: wymagane od '_RandomAccessIterator std::__unguarded_partition_pivot(_Random) , _RandomAccessIterator, _Compare) [z _RandomAccessIterator = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<char>*, std::__cxx1998::vector<std:::charloc_string ::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]’ /usr/include/c++/4.8/bits/stl_algo.h:2360:62: wymagane od ‘void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [z _RandomAccessIterator = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<char>*<c_xx>,std:::__ar ::allocator<std::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Rozmiar = długi int; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' /usr/include/c++/4.8/bits/stl_algo.h:5513:44: wymagane od 'unieważnij std::sort(_RAIter, _RAIter, _Compare) [z _RAIter = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std::alloc :basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' util.cc:280:61: wymagane stąd /usr/include/c++/4.8/bits/stl_algo.h:110:28: błąd: brak dopasowania dla wywołania '(std::__debug::vector<std::basic_string<znak> >) (std::basic_string<znak>&, std::basic_string<znak>&)' if (__comp(*__a, *__b)) ^ /usr/include/c++/4.8/bits/stl_algo.h:112:25: błąd: nie dopasowanie dla wywołania '(std::__debug::vector<std::basic_string<znak> >) (std::basic_string<znak>&, std::basic_string<znak>&)' if (__comp(*__b, *__c)) ^ /usr/include/c++/4.8/bits/stl_algo.h:114:30: błąd: brak dopasowania dla wywołania '(std::__debug::vector<std::basic_string<znak> >) (std::basic_string<znak>&, std::basic_string<znak>&)' else if (__comp(*__a, *__c)) ^ /usr/include/c++/4.8/bits/stl_algo.h:117: 33: błąd: brak dopasowania dla wywołania '(std::__debug::vector<std::basic_string<znak> >) (std::basic_string<znak>&, std::basic_string<znak>&)' else if (__komp(*__a, *__c))^ /usr/include/c++/4.8/bits/stl_algo.h:119:33: błąd: brak dopasowania dla wywołania '(std::__debug::vector<std::basic_string<znak> >) (std:: basic_string<znak>&, std::basic_string<znak>&)' else if (__comp(*__b, *__c)) ^ /usr/include/c++/4.8/bits/stl_algo.h: W instancji '_RandomAccessIterator std ::__unguarded_partition(_RandomAccessIterator, _RandomAccessIterator, const _Tp&, _Compare) [z _RandomAccessIterator = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<stdxx:::var> >, std::allocator<std::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Tp = std::basic_string<znak>; _Compare = std::__debug::vector<std::basic_string<char> >]': /usr/include/c++/4.8/bits/stl_algo.h:2319:78: wymagane od '_RandomAccessIterator std::__unguarded_partition_pivot(_Random) , _RandomAccessIterator,_Porównaj) [z _RandomAccessIterator = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std:::allocator <znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' /usr/include/c++/4.8/bits/stl_algo.h:2360:62: wymagane od 'void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [z _RandomAccessIterator = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<char>*, std::__cxx1998::vector<std:::basic> std::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Rozmiar = długi int; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' /usr/include/c++/4.8/bits/stl_algo.h:5513:44: wymagane od 'void std::sort(_RAIter, _RAIter, _Compare) [z _RAIter = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iteratlub<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std::allocator<std::basic_string<znak> > > >, std::__debug::vector <std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' util.cc:280:61: wymagane stąd /usr/include/c++/4.8/bits/stl_algo.h:2287:35: błąd: brak dopasowania dla wywołania '(std::__debug::vector<std::basic_string<znak> >) (std::basic_string<znak>&, const std::basic_string<znak>&)' while (__comp (*__first, __pivot)) ^ /usr/include/c++/4.8/bits/stl_algo.h:2290:34: błąd: brak dopasowania dla wywołania '(std::__debug::vector<std::basic_string<char > >) (const std::basic_string<znak>&, std::basic_string<znak>&)' while (__comp(__pivot, *__last)) ^ W pliku dołączonym z /usr/include/c++/4.8/bits/ stl_algo.h:61:0, od/usr/include/c++/4.8/algorithm:62, z util.cc:16: /usr/include/c++/4.8/bits/stl_heap.h: W instancji 'void std::__adjust_heap(_RandomAccessIterator, _Distance, _Distance , _Tp, _Compare) [z _RandomAccessIterator = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<char>*, std::__cxx1998::vector<std::basic_string<d:char>, std::basic_string<d:char>, ::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Odległość = długa int; _Tp = std::basic_string<znak>; _Porównaj = std::__debug::vector<std::basic_string<znak> >]': /usr/include/c++/4.8/bits/stl_heap.h:448:15: wymagane od 'unieważnij std::make_heap(_RAIter , _RAIter, _Compare) [z _RAIter = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std:: ::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' /usr/include/c++/4.8/bits/stl_algo.h:1970:47: wymagane od 'void std::__heap_select(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) [z _Compare) ::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std::allocator<std::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' /usr/include/c++/4.8/bits/stl_algo.h:5363:59: wymagane od 'unieważnij std::partial_sort(_RAIter, _RAIter, _RAIter, _Compare) [z _RAIter = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<char>*, std::__cxx1998::vector<std::basic_string<d::alloc, std::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]’ /usr/include/c++/4.8/bits/stl_algo.h:2355:68: required z 'void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [z _RandomAccessIterator = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std,<std:::chector> :basic_string<znak>, std::allocator<std::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Rozmiar = długi int; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' /usr/include/c++/4.8/bits/stl_algo.h:5513:44: wymagane od 'unieważnij std::sort(_RAIter, _RAIter, _Compare) [z _RAIter = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std::alloc :basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' util.cc:280:61: wymagane stąd /usr/include/c++/4.8/bits/stl_heap.h:313:40: błąd: brak dopasowania dla wywołania '(std::__debug::vector<std::basic_string<znak> >) (std::basic_string<znak>&, std::basic_string<znak>&)' *(__first + (__secondChild - 1)))) ^ /usr/include/c++/4.8/bits/ stl_heap.h: W instancji '_Distance std::__is_heap_until(_RandomAccessIterator, _Distance, _Compare) [z _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::basic_string<char::__ector<std:: <znak>, std::allocator<std::basic_string<znak> > > >; _Odległość = długa int; _Porównaj = std::__debug::vector<std::basic_string<znak> >]': /usr/include/c++/4.8/bits/stl_heap.h:113:55: wymagane od 'bool std::__is_heap(_RandomAccessIterator , _Porównaj, _Odległość) [z _RandomAccessIterator = __gnu_cxx::__normal_iterator<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std::allocator<std::basic > > > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >; _Odległość = długa int]”/usr/include/c++/4.8/bits/stl_heap.h:124:76: wymagane od 'bool std::__is_heap(_RandomAccessIterator, _RandomAccessIterator, _Compare) [z _RandomAccessIterator = __gnu_cxx::__normaling::basic_std *, std::__cxx1998::vector<std::basic_string<znak>, std::allocator<std::basic_string<znak> > > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' /usr/include/c++/4.8/bits/stl_heap.h:501:7: wymagane od 'unieważnij std::sort_heap(_RAIter, _RAIter, _Compare) [z _RAIter = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std::alloc :basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Compare = std::__debug::vector<std::basic_string<char> >]' /usr/include/c++/4.8/bits/stl_algo.h:5364:47: wymagane od 'void std::partial_sort(_RAIter, _RAIter, _RAIter, _Compare) [z _RAIter = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std::allocator<std::basic_string<znak> > > >, std::__debug::vector<std ::podstawowy_ciąg<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' /usr/include/c++/4.8/bits/stl_algo.h:2355:68: wymagane od 'void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [z _RandomAccessIterator = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<char>*, std::__cxx1998::vector<std:::basic> std::basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Rozmiar = długi int; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' /usr/include/c++/4.8/bits/stl_algo.h:5513:44: wymagane od 'unieważnij std::sort(_RAIter, _RAIter, _Compare) [z _RAIter = __gnu_debug::_Safe_iterator<__gnu_cxx::__normal_iterator<std::basic_string<znak>*, std::__cxx1998::vector<std::basic_string<znak>, std::alloc :basic_string<znak> > > >, std::__debug::vector<std::basic_string<znak> > >; _Porównaj = std::__debug::vector<std::basic_string<znak> >]' util.cc:280:61: wymagane stąd /usr/include/c++/4.8/bits/stl_heap.h:94:50: błąd: brak dopasowania dla wywołania '(std::__debug::vector<std::basic_string<znak> >) (std::basic_string<znak>&, std::basic_string<znak>&)' if (__comp( __first[__parent], __first[__child])) ^ FWIW.. Zaczynam myśleć, że komentarz powinien dodać "niemożność zrozumienia składni sortowania" jako kolejny możliwy powód przejścia do algorytmu opartego na mapie... Zadziwiające jak 1 linia może wygenerować tak wiele konkurencyjnych komunikatów o błędach... _arg!_ Jak odróżnić operacje wywoływane na wektorze od łańcucha w wektorze. Założyłem (naiwnie), że aby wywołać operację na łańcuchu w tablicy, musiałbym użyć jakiegoś „specyfikatora”, takiego jak „auto” w pętli „for” before lub nawiasy dla konkretnego elementu. Ale najwyraźniej nie tak... Doceniamy kijki wskazówek!


title: Jak działa buforowanie oparte na kluczach?

text: Niedawno przeczytałem artykuł na blogu 37Signals i zastanawiam się, jak to jest, że dostają klucz pamięci podręcznej. Dobrze jest mieć klucz pamięci podręcznej, który zawiera znacznik czasu obiektu (oznacza to, że po aktualizacji obiektu pamięć podręczna zostanie unieważniona); ale jak użyć klucza pamięci podręcznej w szablonie bez powodowania trafienia DB dla samego obiektu, który próbujesz pobrać z pamięci podręcznej. W szczególności, jak to wpływa na relacje jeden do wielu, w których renderujesz na przykład komentarze posta. Przykład w Django: {% for comment in post.comments.all %} {% cache comment.pk comment.modified %} <p>{{ post.body }}</p> {% endcache %} {% endfor % } Czy buforowanie w Railsach jest inne niż na przykład żądania do memcached (wiem, że konwertują twój klucz pamięci podręcznej na coś innego). Czy buforują również klucz pamięci podręcznej?


title: Jak zaktualizować ostatni dostęp za pomocą pliku cookie uwierzytelniania formularzy?

text: Mam witrynę MVC 4, w której używam uwierzytelniania formularzy. Ustawiam plik cookie, gdy użytkownik się loguje. Większość mojej witryny NIE wymaga jednak, aby użytkownik był zalogowany. Co chciałbym zrobić, za każdym razem, gdy użytkownik PIERWSZY uzyskuje dostęp do mojej witryny, chciałbym zaktualizować moje „LastLogon”, które przechowuję w mojej tabeli bazy danych, do odpowiedniej wartości (jeśli Request.IsAuthenticated). Ale nie chcę, aby uruchamiał się na KAŻDEJ stronie, na którą wchodzi użytkownik. Gdzie więc mogę śledzić, kiedy użytkownik po raz pierwszy wchodzi na moją witrynę? Czy to jest w Global.asax? Czy metoda Application_Start jest stosowana dla wszystkich pierwszych żądań do witryny, czy też jest to metoda, gdy witryna ładuje się po raz pierwszy po iisreset?


title: Popularność Lisp rośnie. Ktoś wie dlaczego? Widziałeś to z pierwszej ręki?

text: Niedawno znalazłem ten artykuł/tablicę: http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html Pokazuje to duży wzrost popularności Lispa. Czy ktoś wie więcej na ten temat? W jakich zastosowaniach zyskuje popularność? Czy ostatnio jest więcej prac związanych z Lispem? Dlaczego nie ma podobnego wzrostu w programie Scheme? Jestem entuzjastką Lisp i Scheme, więc nie mogę się doczekać, kiedy to zobaczę. Nigdy nie używałem ich zawodowo, ale bardzo bym chciał. Jeśli ktoś wie więcej na ten temat, chciałbym to usłyszeć.


title: Jak zwięźle drukowane są niektóre pływaki IEEE 754?

text: Używając tego kalkulatora, mogę zobaczyć, jak dziesiętne „.8” i wyrażenie „.7 + .1” mają różne reprezentacje: .8 = 1.1001100110011001100110011001100110011001100110011010 *2-1 .7 + .1 = 1.1001100110011001100110011001100110011001100110011001 *2-1 ^^ Ale jaki mechanizm powoduje wydrukowanie "0.8" dla najwyższej wartości? Np. `alert(.8)` w JavaScript. Dlaczego nie wyświetla czegoś takiego jak „0.800000011920929”? Czy jest to funkcja IEEE 754 lub implementujący ją język programowania?


title: Kiedy rozróżniać wersje systemu operacyjnego w nazwach kanonicznych dla platform docelowych?

text: Chciałbym uporządkować wydania oprogramowania mojej firmy według platformy. Przyjrzałem się, jak Mozilla, Perforce i Apache organizują swoje wydania i wydaje mi się, że powinienem partycjonować według architektury systemu operacyjnego i procesora. Myślałem o czymś takim: * Linux (x86-32) * Linux (x86-64) * Neutrino (x86-32) * Windows (x86-32) * Windows (x86-64) Czy często rozróżnia się wersje Windows, Linux czy OS X? Na przykład, czy powinienem określać wersję jądra Linux?


title: Potok transformacji danych

text: Stworzyłem pewnego rodzaju potok danych, aby przekształcić dane o współrzędnych w bardziej przydatne informacje. Oto powłoka potoku: public class PositionPipeline { protected List<IPipelineComponent> components; public PositionPipeline() { komponenty = new List<IPipelineComponent>(); } public PositionPipelineEntity Process(Position position) { foreach (składnik var w składnikach) { position = component.Execute(position); } pozycja powrotu; } public PositionPipeline RegisterComponent(IPipelineComponent komponent) { components.Add(component); zwróć to; } } Każdy `IPipelineComponent` akceptuje i zwraca ten sam typ — `PositionPipelineEntity`. Kod: interfejs publiczny IPipelineComponent { PositionPipelineEntity Execute(PositionPipelineEntity position); } `PositionPipelineEntity` musi mieć wiele właściwości, z których wiele jest **nieużywanych w niektórych komponentach** i **wymaganych w innych**. Niektóre nieruchomości staną się również zbędne na końcu rurociągu. Na przykład, te komponenty mogą być wykonane: 1. `TransformCoordinatesComponent`: Parsuje surowe dane współrzędnych do typu Coordinate. 2. `DetermineCountryComponent`: Określa i przechowuje kod kraju. 3. `DetermineOnRoadComponent`: Określ i zapisz, czy współrzędna znajduje się na drodze. Kod: potok .RegisterComponent(new TransformCoordinatesComponent()) .RegisterComponent(new DetermineCountryComponent()) .RegisterComponent(new DetermineOnRoadComponent()); Pipeline.Process(positionPipelineEntity); Typ `PositionPipelineEntity`: public class PositionPipelineEntity { // Dotyczy tylko TransformCoordinatesComponent public dziesiętny RawCoordinateLatitude { get; ustawić; } // Dotyczy tylko publicznego elementu dziesiętnego TransformCoordinatesComponent RawCoordinateLongitude { get; ustawić; } // Wymagane przez wszystkie składniki po TransformCoordinatesComponent public Coordinate CoordinateLatitude { get; ustawić; } // Wymagane przez wszystkie składniki po TransformCoordinatesComponent public Coordinate CoordinateLongitude { get; ustawić; } // Ustaw w DetermineCountryComponent, nigdzie nie jest wymagany. // Wymaga CoordinateLatitude i CoordinateLongitude (TransformCoordinatesComponent) public string CountryCode { get; ustawić; } // Ustaw w DetermineOnRoadComponent, nigdzie nie jest wymagany. // Wymaga CoordinateLatitude i CoordinateLongitude (TransformCoordinatesComponent) public bool OnRoad { get; ustawić; } } **Problems:** * Jestem bardzo zaniepokojony zależnością składnika od właściwości. Sposobem na rozwiązanie tego byłoby stworzenie określonych typów dla każdego komponentu. Problem polega więc na tym, że nie mogę ich połączyć w ten sposób. * Innym problemem jest kolejność komponentów w rurociągu. Istnieje pewna zależność. Obecna struktura nie zapewnia żadnego statycznego ani sprawdzania w czasie wykonywania dla takich rzeczy. Wszelkie opinie będą mile widziane.


title: Wolne ładowanie graficznego interfejsu użytkownika na pulpicie

text: Opracowuję GUI oparty na desktopie (single form) przy użyciu wxPython i ładuję go za pomocą zdalnego dostępu do citrix z prywatnej sieci klienta. Załóżmy, że GUI zawiera pewną grupę pól wyboru i pól tekstowych, które są ładowane razem podczas uruchamiania aplikacji. Wartość pól wyboru pochodzi z bazy danych i na podstawie wyboru wartości pola wyboru odpowiednie pola tekstowe (początkowo puste) są wypełniane z bazy danych. Teraz problem polega na tym, że ze względu na powolny dostęp zdalny musimy długo czekać (około 5-7 minut) zanim wszystkie kontrolki zostaną załadowane. Czy jest jakaś sugestia, czy możemy skrócić ten czas? Jednym ze sposobów, w jaki przychodzi na myśl pierwsza myśl, jest podzielenie GUI na wiele kart i podzielenie kontrolek między kartami. W ten sposób muszę załadować mniej kontrolek po uruchomieniu aplikacji, aby wyświetlić pierwszą kartę. Inne kontrolki ładują się dopiero po kliknięciu przez użytkownika odpowiedniej zakładki. Inny sposób, czy ten jest najlepszym podejściem?


title: Termin dla testów jednostkowych, który oddziela logikę testu od danych wyników testu

text: Więc nie robię żadnych testów jednostkowych. Ale wpadłem na pomysł, aby był bardziej odpowiedni dla mojego obszaru zastosowań. Nie jest jednak jasne, czy coś takiego istnieje i czy, jak by to się nazywało. * * * Zwykłe testy jednostkowe łączą logikę testu i oczekiwany wynik. Zasadniczo platforma testowa sprawdza tylko wartości logiczne (czy to pasowało, czy oczekiwany wynik). Aby uogólnić, sam kod testu odwołuje się do kontrolowanych funkcji, a także określa wartości wyników w następujący sposób: unit::assert( test_me() == 17 ) To, czego szukam, to oddzielenie obaw. Sam test powinien zawierać tylko przetestowaną logikę. Dane wynikowe i wynikowe powinny być obsługiwane przez ramy testów jednostkowych lub asercji. Na przykład: unit::probe( test_me() ) Tutaj `sonda` faktycznie podwaja się jako kolektor w pierwszym uruchomieniu, a potem jako metoda weryfikacji. Oczekiwana „17” nie jest wymieniona w kodzie testowym, ale jest przechowywana lub zarządzana gdzie indziej. Jak nazywa się ten schemat? Jak byś to nazwał? Mam nadzieję, że uda mi się znaleźć kilka rzeczywistych implementacji z odpowiednią terminologią. * * * Oczywiście taki schemat nie pasuje do TDD. Służy wyłącznie do testowania regresji. Oczywiście nie można go stosować we wszystkich przypadkach. Tylko prostsze przedmioty testowe mogą być analizowane w ten sposób, dla czegokolwiek innego wymagane są zwykłe kroki konfiguracji testu jednostkowego i asercji. I tak, można to zrobić ręcznie, tworząc ResultWhateverObject, ale nadal wymagałoby to podłączenia go do logiki testu. Pamiętaj też, że pytam o języki skryptowe, a nie o Javę. Zdaję sobie sprawę, że wzorzec xUnit pochodzi z tego miejsca i dlaczego jest tak skomplikowany, jak jest. Btw, odkryłem jeden framework do wykonywania testów, który pozwala skrócić proste notacje testowe do: test_me(); // 17 Chociaż w ten sposób dane wynikowe nie są już kodowane (jest to komentarz), to nadal nie jest to całkowite oddzielenie i oczywiście działałoby tylko dla wyników skalarnych.


title: Różnica między kontrolą oprogramowania a weryfikacją

text: Czytałem o inspekcji oprogramowania w Inżynierii Oprogramowania autorstwa Iana Summerville'a i natknąłem się na termin inspekcja oprogramowania i zacząłem o nim czytać na Wikipedii. Nie rozumiem, jaka jest różnica między weryfikacją a inspekcją oprogramowania?


title: Niedrogie generowanie hierarchicznych unikalnych identyfikatorów

text: Moja aplikacja buduje strukturę hierarchiczną w następujący sposób: root = { 'id': 'root', 'children': [{ 'name': 'root_foo', 'children': []}, { 'id': 'root_foo2 ', 'children': [ { 'id': 'root_foo2_bar', 'children': [] } ] } ] } innymi słowy, jest to drzewo węzłów, gdzie każdy węzeł może mieć elementy potomne i unikalny identyfikator, który nazywam " ID". Po dodaniu nowego dziecka muszę wygenerować dla niego unikalny identyfikator, jednak mam dwa problemy: * _identyfikatory stają się zbyt długie_ * _dodawanie wielu dzieci trwa wolniej, ponieważ muszę znaleźć pierwszy dostępny identyfikator_ Moje wymaganie to: * _nazywanie potomka X musi być określone tylko ze stanu ich przodków_ * _Gdy regeneruję drzewo o tej samej zawartości, identyfikatory muszą być takie same_ lub innymi słowy, gdy mamy węzły A i B, tworząc dziecko w A, nie może wpływają na nazwę nadaną dzieciom B. Wiem, że jednym ze sposobów optymalizacji byłoby wprowadzenie licznika w każdym węźle i dołączenie go do nazw, co rozwiąże mój problem z wydajnością, ale nie rozwiąże problemu za pomocą „długich identyfikatorów”. **Czy możesz mi zaproponować algorytm szybkiego wymyślania nowych identyfikatorów?**


title: Jakie jest najlepsze podejście do komentarzy w kodzie inline?

text: Przeprowadzamy refaktoryzację w 20-letniej starszej bazie kodu i rozmawiam z kolegą na temat formatu komentarzy w kodzie (plsql, java). Nie ma domyślnego formatu komentarzy, ale w większości przypadków ludzie robią coś takiego w komentarzu: // data (rok, rok-miesiąc, rrrr-mm-dd, dd/mm/rrrr), (identyfikator autora, autor nazwisko, pseudonim autora) i komentarz Proponowany format przyszłych i przeszłych komentarzy, który chcę to: // {rrrr-mm-dd}, unique_author_company_id, comment Mój kolega twierdzi, że potrzebujemy tylko komentarza i musimy ponownie sformatować wszystkie przeszłe i przyszłe komentarze do tego formatu: // komentarz Moje argumenty: * Mówię ze względów konserwacyjnych, że ważne jest, aby wiedzieć, kiedy i kto dokonał zmiany (nawet ta informacja jest w SCM). * Kod żyje i dlatego ma swoją historię. * Ponieważ bez dat zmian nie można wiedzieć, kiedy zmiana została wprowadzona bez otwarcia narzędzia SCM i wyszukiwania w długiej historii obiektów. * bo autor jest bardzo ważny, zmiana autorów jest bardziej wiarygodna niż zmiana autora * względy Agility, nie trzeba otwierać i poruszać się po narzędziu SCM * ludzie bardziej baliby się zmienić coś, co ktoś zrobił 15 lat temu, niż coś, co zostało niedawno stworzone lub zmienione. * itd. Argumenty kolegi: * Historia jest w SCM * Deweloperzy nie mogą być świadomi historii kodu bezpośrednio w kodzie * Pakiety mają długość 15k linii, a nieustrukturyzowane komentarze sprawiają, że te pakiety są trudniejsze do zrozumienia Co twoim zdaniem jest najlepsze podejście? A może masz lepsze podejście do rozwiązania tego problemu?


title: Uzasadnienie projektów freeware

text: Widziałem w przeszłości kilka darmowych projektów, w których autor (autorzy) zainwestował znaczną ilość swojego osobistego czasu i zasobów i nigdy nawet nie rozważał pobierania opłat za oprogramowanie. Wiele z tych projektów opierało się na darowiznach iz tego, co słyszałem, darowizny nigdy nie mogą być opłacalnym modelem biznesowym (nawet po to, by pokryć koszty rozwoju), ponieważ większość ludzi decyduje się nie wpłacać darowizn, jeśli mają taką możliwość. Wiele z tych projektów ostatecznie zamknięto, ponieważ ich autorzy nie mogli ich dalej utrzymywać. To prawda, że niektórzy ludzie po prostu lubią uszczęśliwiać społeczność (lub coś w tym rodzaju), ale jeśli walczysz o utrzymanie swojego projektu przy życiu, dlaczego nie pobrać niewielkiej kwoty, takiej jak 10 USD, po prostu za utrzymanie działania? Jeśli ludzie uznają twoje oprogramowanie za przydatne (a wiele osób uznało te projekty za BARDZO przydatne), nie będą mieli problemu z zapłaceniem tak małej kwoty. Pytanie brzmi: jeśli masz popularną aplikację, którą ludzie lubią i pobierają w dużych ilościach, dlaczego nie umieścić na niej metki z ceną? Dlaczego to za darmo?


title: Czy algorytmy wyszukiwania ścieżek mają praktyczne zastosowanie poza tworzeniem gier?

text: Interesuje mnie, czy algorytmy wyszukiwania ścieżek oparte na heurystyce, takie jak A*, mają jakiekolwiek praktyczne zastosowanie poza sferą tworzenia gier. Czy istnieją inne dziedziny inżynierii oprogramowania, które wykorzystują algorytmy odnajdywania ścieżek, być może w zupełnie inny lub niekonwencjonalny sposób, czy też z natury tych algorytmów i ich konstrukcji ostatecznie widzą bardzo ograniczone zastosowanie w innych obszarach?


title: Czy to zły pomysł, aby uzyskać tytuł magistra i licencjata na tej samej uczelni?

text: Zbliżam się do ukończenia studiów i zdecydowanie rozważam kontynuowanie studiów magisterskich. Moim długoterminowym celem na przyszłość jest pozostanie w przemyśle, a nie doktorat/karierę akademicką. Podczas przekazywania tych myśli niektórym moim rówieśnikom powiedziano mi, że pozostawanie na tym samym uniwersytecie zarówno na studiach licencjackich, jak i magisterskich jest niewskazane. Wydaje się, że przyczyny są oparte na braku kontaktu z innymi możliwościami, programami i wykładowcami. Moje pytanie brzmi, czy jeśli zamierzam kontynuować karierę poza spektrum doktoranckim / akademickim, czy pozostanie na tym samym uniwersytecie dla mojego magistra naprawdę zmniejszy moją wartość na stanowiskach związanych z oprogramowaniem? Jeśli tak (lub jeśli nie), dlaczego?


title: iphone app - czy można wywołać lokalną aplikację po odwiedzeniu strony internetowej lub aplikacji internetowej?

text: Mam scenariusz, w którym lokalna aplikacja jest używana do robienia zdjęć za pomocą aparatu iPhone'a, a lokalna aplikacja może wysłać zdjęcie na serwer sieciowy... Teraz, gdy użytkownik odwiedza witrynę internetową lub inną aplikację internetową za pomocą swojego iPhone'a, strona internetowa /webapp wywołuje aplikację lokalną, aby wykonać swoją pracę. Czy ograniczenia bezpieczeństwa/inne na iPhonie uniemożliwiają wdrożenie takiego scenariusza? Czy mogę utworzyć aplikację lokalną, mając na uwadze powyższy scenariusz? Czy jest coś, o czym powinienem wiedzieć, zanim zacznę tworzyć taką aplikację? A czy użytkownik powinien odwiedzić aplikację internetową lub stronę internetową, aby aplikacja lokalna była poprawnie wywoływana w celu wykonania swojej pracy?


title: Czy korzystasz z ReSharper w pełnym wymiarze godzin, czy włączasz go tylko w razie potrzeby?

text: Opierając się na wielu pytaniach związanych z tymczasowym wyłączeniem ReSharpera, a także na pewnych danych badawczych, widzę, że znaczna część użytkowników ReSharpera przez większość czasu go wyłącza. Zwykle włączają go na ograniczony czas (powiedzmy kilka godzin), robią wszystko, co muszą, korzystając z jego funkcji, i wyłączają go z powrotem do następnego razu, gdy poczują, że muszą go użyć. Jeśli używasz ReSharper (lub innych podobnych rozszerzeń VS, jeśli o to chodzi) w taki sporadyczny sposób, czy możesz wyjaśnić, dlaczego to robisz? Czy Twoje zachowanie opiera się na wynikach lub innych względach? Jakie rodzaje zadań włączasz ReSharper w tym scenariuszu?


title: Dokładność obliczania odległości od urządzenia z Androidem za pomocą całki podwójnej?

text: Używając `TYPE_LINEAR_ACCELERATION` załóżmy, że odkryłem, że urządzenie porusza się z prędkością 4 m/s². a(t)=s"(t)=+4 v(t)=∫4tdt s(t)=2/3t³ s(3)=18m Jaka byłaby dokładność?


title: Jak wykorzystać kontrolę źródła w analizie danych?

text: Obecnie zajmuję się analizą danych i używam głównie SPSS (statystyki) i raczej nieznanego języka skryptowego do tworzenia ładnych tabel. Mój problem polega na tym, że istnieje wiele plików skryptów dla obu programów z tysiącami linii kodu. Obecnie są one kopiowane co miesiąc do nowego folderu, w razie potrzeby modyfikowane i wykonywane. Przewiduje się, że istnieje wiele błędów kopiowania i wklejania, a wyszukiwanie początku błędu jest ogromnym bólem. Myślałem o kontroli źródła, ale nie wiem, który z nich spełnia następujące kryteria: 1\. checkin z Eksploratora Windows lub Notepad++ 2\. Zatwierdzanie tego samego projektu z różnych folderów. 3\. Czy ktoś ma dobre pomysły lub sugestie dotyczące najlepszych praktyk? Używam trochę SVN dla kilku małych programów C# — ale czy istnieje lepsze narzędzie do zarządzania kodem źródłowym w tych okolicznościach?


title: Modele klient-serwer i modele zorientowane na klienta

text: W przypadku aplikacji rozproszonych należy podkreślić: > Klasyczne systemy oprogramowania z ubiegłego stulecia były w większości oparte na > **Modele klient-serwer** i **Tworzeniu aplikacji zorientowanych na klienta**, > **Oba ostatecznie działały na jednym komputerze , czy to komputer kliencki, czy > serwer.** 1. Rozumiem, co to są modele klient-serwer, ale zastanawiałem się, co to jest model zorientowany na klienta? 2. Jak należy rozumieć, że „oba ostatecznie działają na jednym komputerze, czy to na komputerze klienckim, czy na serwerze”? Czy dotyczy to zarówno modeli klient-serwer, jak i modeli zorientowanych na klienta?


title: Piszesz protokół TCP lub używasz HTTP do przesyłania plików?

text: Chcę napisać aplikację po stronie serwera, która pozwala kilku użytkownikom na wymianę plików (nie powyżej 3 MB) w następujący sposób: użytkownik A łączy się z (serwer) S. Użytkownik B łączy się z S. Użytkownik C łączy się z S. Użytkownik A wysyła plik . Użytkownicy B i C „widzą”, że plik został/jest przesyłany i zaczynają go pobierać. Moim głównym zmartwieniem jest responsywność. Chcę, aby plik dotarł do punktów B i C niedługo po rozpoczęciu przesyłania A. Myślałem o zrobieniu tego za pomocą HTTP: użytkownik A wysyła surowe bajty do serwera, a serwer zapisuje plik lokalnie. W tym momencie użytkownicy B i C widzą, że plik został przesłany i zaczynają go pobierać. Moje pytanie: czy HTTP jest najlepszym sposobem, aby się tu dostać? A może powinienem napisać aplikację korzystającą z gniazd TCP i napisać własny protokół? Jeśli pójdę z gniazdkami. Jak mogę oszacować wymagania dotyczące pamięci RAM serwera VPS, aby móc jednocześnie zezwolić na N połączeń transferu plików?


title: Jak zespoły programistów mogą zapobiegać niskiej wydajności w aplikacjach konsumenckich?

text: Kiedy wcześniej zapytałem, co jest odpowiedzialne za wolne oprogramowanie, kilka odpowiedzi, które otrzymałem, sugerowało, że jest to problem społeczny i związany z zarządzaniem: > To nie jest problem techniczny, to problem marketingowy i zarządczy.... > Ostatecznie produkt menedżerowie są odpowiedzialni za napisanie specyfikacji > tego, co ma otrzymać użytkownik. Wiele rzeczy może pójść nie tak: Menedżer produktu nie umieszcza odpowiedzi na przycisk w specyfikacji… Pracownicy ds. kontroli jakości wykonują > przeciętną pracę polegającą na testowaniu zgodności ze specyfikacją… jeśli kierownictwo produktu i pracownicy ds. kontroli jakości śpią o koła, my, programiści, nie możemy tego nadrobić. > —Bob Murphy > > Ludzie pracują nad aplikacjami o dużych rozmiarach. Gdy działają, pojawiają się problemy z wydajnością, > tak jak błędy. Różnica polega na tym, że błędy są "złe" - wołają "znajdź mnie, > i napraw". Problemy z wydajnością po prostu siedzą i stają się coraz gorsze. Programiści > często myślą: „Cóż, mój kod nie miałby problemów z wydajnością. Raczej > kierownictwo musi kupić mi nowszą/większą/szybszą maszynę”. Faktem jest, że jeśli programiści okresowo po prostu polują na problemy z wydajnością (co jest w rzeczywistości bardzo proste), mogliby je po prostu usunąć. —Mike Dunlavey Jeśli więc jest to problem społeczny, jakie mechanizmy społeczne może wprowadzić organizacja, aby uniknąć dostarczania powolnego oprogramowania do swoich klientów?


title: Automatyczne sortowanie członków klasy/modułu i jego możliwy wpływ na produktywność i jakość kodu

text: Ostatnio widziałem możliwości niektórych IDE (poprzez wtyczki) do sortowania członków ich klas/modułów na podstawie pewnych kryteriów, dzięki czemu możesz mieć wszystko posortowane automatycznie, bez względu na to, gdzie umieścisz elementy w momencie pisania do edytora. Czy uważasz, że tego rodzaju sortowanie w klasie/module może mieć pozytywny wpływ na produktywność, czytelność, zrozumiałość itp.?


title: Pisanie przypadków użycia dla dość złożonego scenariusza

text: Próbuję poprawić moje umiejętności pisania przypadków użycia, ale utknąłem w pewnym scenariuszu. Pomysł polega na tym, że na liście zadań znajduje się kilka wpisów (jakaś lista rzeczy do zrobienia). Teraz użytkownik chce przetworzyć listę (podzielić ją między innymi listami). Może to zrobić, odpowiadając na serię pytań / uzupełniając dodatkowe dane. Na podstawie wyborów użytkownika system wykonuje różne działania na zadaniu. Naprawdę nie wiem, jak to zapisać w przypadku użycia. To, o czym myślałem, to coś takiego (piszę tylko główny scenariusz sukcesu): Przypadek użycia: Przetwarzanie Skrzynka odbiorcza Główny aktor: Użytkownik 1. Użytkownik wskazuje, że chce posortować swoją skrzynkę odbiorczą 2. System przedstawia następne pytanie i zapewnia możliwe działania 3. Użytkownik dokonuje wyboru _kroki 2-3 są powtarzane, aż skrzynka odbiorcza będzie pusta_ Problem polega na tym, że nie jest wystarczająco szczegółowy, więc innym, o czym myślałem, jest utworzenie podrzędnych przypadków użycia dla wszystkich różnych kroków w proces pytań typu: Przypadek użycia: Obsługa projektu Poziom: Podprzypadek użycia Główny aktor: System 1. System żąda od użytkownika dodatkowych informacji (opis, termin). 2. Użytkownik uzupełnia dane 3. System klasyfikuje zadanie jako Projekt Jestem zdziwiony: * Jak poprawnie uwzględnić ten podprzypadek użycia w moim głównym scenariuszu * Jak wskazać, że po tej akcji, użytkownik zaczyna ponownie od kroku 2 w głównym przypadku użycia. Myślałem o użyciu rozszerzeń, w których uwzględniam różne podrzędne przypadki użycia, ale robi się to dość zagmatwane. Tak więc, aby połączyć tę prośbę w jedno pytanie: Czy ktoś może wyjaśnić, w jaki sposób zwykle radziłbyś sobie z tego rodzaju scenariuszami i/lub podać mi podstawowe możliwe rozwiązanie dla tego przykładu? Z góry dziękuję ;) Jeśli ktoś jest zainteresowany, schemat pytań, które zamierzam wykorzystać, pochodzi z książki Davida Allena Getting Things Done: link do diagramu


title: Dlaczego C++ jest znany jako „przedwczesna optymalizacja”?

text: "Programowanie w C++ to przedwczesna optymalizacja" Dlaczego ~~wszyscy~~ tak mówią?


title: Po co tworzyć bezpłatne programy o otwartym kodzie źródłowym?

text: Dlaczego ktoś miałby poświęcać swój czas na opracowanie projektu open-source za darmo i bez wynagrodzenia?


title: Jakie jest ekonomiczne uzasadnienie skupienia się na darmowych projektach open source?

text: > **Możliwy duplikat:** > Dlaczego programować open source? Mam problem ze zrozumieniem, dlaczego ludzie poświęcają swój czas na projekt open source, który jest darmowy jak piwo, zamiast skupiać się na zamkniętym, płatnym projekcie. Projekty z zamkniętym kodem źródłowym wydają się być bardziej opłacalne komercyjnie, więc dlaczego programiści otwierają kod źródłowy i udostępniają go bezpłatnie, gdy są ku temu możliwości komercyjne?


title: Co sprawiło, że przyczyniłeś się do tego projektu open source?

text: Interesują mnie prawdziwe doświadczenia i osobiste odpowiedzi, a nie tylko te standardowe, zużyte „korzyści z wkładu w open source”, które wszyscy znamy już na pamięć. Spotkałem wielu ludzi, którzy przyczyniają się do projektu open source i prawie nigdy nie pojawił się ten temat: dlaczego oni przyczynili się do tego projektu open source. Tak więc, jeśli w jakikolwiek sposób przyczyniałeś się już do projektu open source, możesz zatrzymać się na chwilę i spróbować przypomnieć sobie, co tak naprawdę skłoniło Cię do wniesienia wkładu do tego konkretnego projektu. Czy była to przypadkowa decyzja, czy to dlatego, że się nudziłeś, czy dlatego, że firma, w której pracowałeś, już z niej korzystała i wniosłeś wkład w ramach swojej pracy, czy to dlatego, że projekt był zbyt duży, chciałeś zdobyć kontrakty, czy projekt był zbyt mały, chciałeś go zbudować, lub dlatego, że twój prof. , okazjonalny, lekki, jednorazowy).


title: Czy muszę skontaktować się z prawnikiem, aby zgłosić naruszenie GPL w oprogramowaniu rozpowszechnianym w sklepie Apple App Store?

text: Jakaś firma sprzedaje oprogramowanie za pośrednictwem Apple App Store, które wykorzystuje fragmenty kodu, które udostępniłem publicznie na licencji GPL. Firma narusza warunki licencji na dwa sposoby, (1) nie zachowując mojego oświadczenia o prawach autorskich i nie udostępniając swojego kodu na licencji GPL oraz (2) rozpowszechniając mój kod na licencji GPL za pośrednictwem sklepu Apple App Store. (Fundacja Wolnego Oprogramowania wyjaśniła, że warunki GPL i App Store są niezgodne.) Chcę zgłosić to firmie Apple i poprosić o podjęcie odpowiednich działań. Próbowałem wysłać je pocztą z prośbą o dodatkowe informacje na temat procesu zgłaszania i otrzymałem automatyczną odpowiedź zacytowaną poniżej. Ostatni punkt na liście rzeczy, które należy podać, „oświadczenie złożone przez ciebie pod groźbą krzywoprzysięstwa” brzmi tak, jakby oznaczało jakiś konkretny dokument prawny. Nie jestem pewny. Czy to oznacza, że muszę skontaktować się z prawnikiem tylko po to, aby złożyć raport? Chciałbym uniknąć tego kłopotu, jeśli to w ogóle możliwe. (Oprócz odpowiedzi na to konkretne pytanie, z chęcią przyjmę komentarze i raporty o doświadczeniach od każdego, kto miał już do czynienia z naruszeniem GPL w sklepie Apple App Store.) > Dziękujemy za skontaktowanie się z agentem ds. praw autorskich firmy Apple. Jeśli uważasz, że Twoja > praca została skopiowana w sposób stanowiący naruszenie w witrynie > Apple, podaj następujące informacje: > > * elektroniczny lub fizyczny podpis osoby upoważnionej do działania > w imieniu właściciela interes praw autorskich; > * opis dzieła chronionego prawem autorskim, które Twoim zdaniem zostało naruszone; > * opis miejsca, w którym materiał, który Twoim zdaniem narusza prawa > znajduje się na stronie; Twój adres, numer telefonu i adres e-mail; > * oświadczenie, że masz w dobrej wierze przekonanie, że kwestionowane wykorzystanie > nie jest autoryzowane przez właściciela praw autorskich, jego przedstawiciela lub prawo; > * oświadczenie złożone przez Ciebie pod karą krzywoprzysięstwa, że powyższe informacje > w Twoim Powiadomieniu są dokładne i że jesteś właścicielem praw autorskich > lub masz upoważnienie do działania w imieniu właściciela praw autorskich. > > > Aby uzyskać więcej informacji, zapoznaj się z informacjami prawnymi firmy Apple i > Powiadomieniami/Roszczeniami dotyczącymi naruszenia praw autorskich pod adresem: > http://www.apple.com/legal/trademark/claimsofcopyright.html > > Aby przyspieszyć rozpatrywanie roszczenia dotyczącego wszelkie domniemane problemy > własności intelektualnej związane z iTunes (muzyka / teledyski, podcasty, telewizja, > filmy), prosimy o przesłanie kopii zawiadomienia na adres iTunesStoreNotices@apple.com > W przypadku roszczeń dotyczących aplikacji prosimy o przesłanie kopii > powiadomienie na adres AppStoreNotices@apple.com. > > Ze względu na dużą liczbę otrzymywanych przez nas wiadomości e-mail może to być jedyna odpowiedź, > którą otrzymasz od copyrightagent@apple.com. Zapewniamy jednak, że > Agent Apple ds. praw autorskich i/lub zespół prawny iTunes niezwłocznie > zbadają i podejmą odpowiednie działania w związku z Twoim zgłoszeniem.


title: Rozproszone tworzenie gier i bezpieczeństwo kodu źródłowego

text: Myślę, że to pytanie było już wielokrotnie zadawane, ale nie mogę znaleźć żadnego z nich. Mam projekt gry (używam Marmalade) i kilku zaufanych programistów, ale chcę zaprosić więcej. Za dodanie funkcjonalności, za pisanie skryptów i tak dalej. Pytanie brzmi - jak mogę nie dać im całego kodu źródłowego (być może tylko skompilowanej jego części) i/lub dać im ograniczone prawa do projektu za wykonanie ich pracy, ale nie mam możliwości kradzieży kodu ?


title: Certyfikowany Scrum Developer — ktoś, kto wziął udział w tym kursie?

text: Poznałem wielu „Certified ScrumMasters” oraz „Certified Scrum Product Owners”… ale jeszcze nie spotkałem „Certified Scrum Developera”. Zobacz: http://scrumalliance.org/pages/certified_scrum_developer Kto uczestniczył w tym kursie. Czy to było cenne? Daj mi znać, jak poszło Twoje doświadczenie. -=-= Edycje -=-= Właśnie zdałem sobie sprawę, jakie są wymagania CSD (poniżej)... co za duże obciążenie pola! > Kwalifikacje CSD > > Co najmniej pięć dni formalnego szkolenia jest wymagane do uzyskania poświadczenia Certified Scrum > Developer (CSD). Wnioskodawcy CSD muszą również wykazać > zrozumienie praktyk inżynierskich zwinnych poprzez zdanie i zdanie formalnej oceny > CSD. > > * Co najmniej trzy dni muszą być szkoleniem technicznym w ramach trzydniowego kursu umiejętności technicznych CSD->. > * Przynajmniej jeden z pięciu dni musi być poświęcony na naukę Scrum > poprzez kurs CSD Wprowadzenie do Scrum lub kurs CSM/CSPO. > * Piąty dzień jest fakultatywny. Możesz wybierać spośród kursów > CSD-track, aby rozwinąć umiejętności, które Twoim zdaniem przyniosłyby największe korzyści w > Twojej roli. Dwudniowy kurs CSM lub CSPO spełnia zarówno wymagania Intro to Scrum, jak i wymagania > do wyboru. >


title: Kiedy NIE jest dobrze używać aktorów w akka/erlang?

text: Pracuję z akka od 7-8 miesięcy codziennie. Kiedy zaczynałem, pracowałem nad aplikacjami i zauważyłem, że aktorzy byliby używani praktycznie w dowolnym miejscu w systemie aktora do komunikacji między większością obiektów. Więc zrobiłem to samo - podkręciłem innego aktora dla x/y/z. Wydaje mi się, że może to być zbyt niewybredne, zwiększając złożoność tam, gdzie nie jest to potrzebne – ale nie mogę znaleźć żadnych dyskusji na temat tego, gdzie należy używać aktorów w porównaniu z zwykłą logiką synchroniczną lub nawet asynchroniczną za pośrednictwem przyszłości. Zacząłem zastanawiać się nad swoim stanowiskiem po tym, jak mój współpracownik wspomniał o czymś podobnym. Ostatnio zdałem sobie sprawę z kilku przypadków, w których zastanawiałem się nad zadaniem, a następnie unikałem tworzenia kolejnego aktora, ponieważ mogłem osiągnąć ten sam wynik bezpiecznie w niezmiennej implementacji - np. Pobranie wartości konfiguracyjnych z bazy danych lub pliku gdzieś, gdzie dostęp jest bardzo rzadki i będzie czekaj, aż wynik jest rzeczywistym przypadkiem użycia. W szczególności wydaje mi się, że w każdym przypadku, gdy bawisz się niezmiennym stanem, aktorzy tworzą złożoność i ograniczają przepustowość - na przykład czysta funkcja w obiekcie może być wywołana jednocześnie bez ryzyka z dowolnym poziomem współbieżności, ale aktor może przetwarzać tylko jedną wiadomość na raz. Alternatywą jest to, że zaparkujesz wątek, jeśli musisz poczekać na wynik, chyba że zaczniesz korzystać z przyszłości, ale w przypadkach, w których nie musisz się martwić o asynchroniczne przesyłanie wiadomości lub skalowanie, wydaje się, że zatrudnienie aktora może być przesadą. Więc moje pytanie brzmi - czy jest zły czas na wykorzystanie aktorów? Jestem ciekawa jak wygląda erlang i bardzo chciałabym mieć wgląd innych ludzi. Lub jeśli istnieją jakieś zasady dotyczące wykorzystania aktorów.


title: Zapobiegaj anomaliom spowodowanym czasem propagacji sygnału

text: Na zajęciach z elektrotechniki dowiedzieliśmy się, że linie sygnałowe nie są idealne, więc potrzeba czasu, aby sygnał dotarł do drugiego końca kabla, a jeśli nie weźmiemy tego pod uwagę, może to prowadzić do szalonych zjawisk, takich jak: ![ wpisz opis obrazka tutaj](http://i.stack.imgur.com/XAsXe.png) Wyobraź sobie, że mamy grę czołgową, w której tank1 (grany z Europy) strzela do tanka2 (kontrolowanego z USA). Na monitorze tank1 widzi, że tank2 jest zniszczony, ale mija trochę (bardzo mały, ale nie bez znaczenia) czas, aby sygnał dotarł do monitora tank2. Tak więc, gdy sygnał się rozchodzi, on również może strzelać ze swojego wirtualnego działa, niszcząc czołg1. Sygnał tego aktu rozpoczyna podróż do tank1, zanim dotrą dane informujące tank2 o jego śmierci. Powoduje to dziwne zjawisko, że **tank1 zniszczył tank2, ale tank2 nadal może zniszczyć gracza1** (pomimo tego, że tank2 nawet nie istnieje). Powiedzieli nam, że nie możemy rozwiązać tego problemu w sposób sprzętowy, musimy temu zapobiec po stronie oprogramowania, ale nie powiedzieli nam, jak mamy to zrobić, ale jestem ciekaw, więc jak my / oni rozwiązują ten problem? Problem nie tkwi w czasie, jaki upływa, gdy pocisk leci w powietrzu, chodzi o to, żeby pierwszy czołg został zniszczony, żeby nie mógł strzelać (lub być w stanie nic zrobić), ale w naszym problemie jest w stanie, ponieważ informacje, które zniszczył, jeszcze nie dotarły. **W tym przypadku należy zinterpretować słowo strzał jako: pocisk trafił i zniszczył czołg**. Tak więc **faktyczny sygnał**, który zostanie wysłany do innego klienta **jest taki, że jest on zniszczony**. Nie przypadek, że wrogi czołg wystrzelił z armaty.


title: VPS vs hosting: który jest dobry dla usług internetowych java

text: Mam kilka pytań dotyczących VPS i hostingu. O ile rozumiem, VPS to maszyna wirtualna, na której możemy zrobić wszystko, co możemy zrobić z naszą maszyną lokalną. Zainstaluj oprogramowanie, zmień ustawienia itp. Hosting to miejsce, w którym mamy tylko folder, w którym umieszczamy naszą stronę internetową. Jednak większość dostawców obecnie reklamuje swoją usługę jako „hosting VPS”. To mnie myli, czy to oznacza, że sprzedają usługę VPS, która może obsługiwać tylko witryny internetowe? Potrzebuję maszyny wirtualnej, która obsługuje jedną usługę Java RESTful przy użyciu serwerów Tomcat i Jersey oraz MYSQL na zapleczu. Moim planem było wynajęcie maszyny VPS, zainstalowanie na niej Tomcata 7 i MySQL. Czy to właściwa droga? Wielkie dzięki.


title: Styl programowania w aplikacjach C++ na dużą skalę

text: Ostatnio przeglądałem kod źródłowy dużych aplikacji napisanych w C++, aby się trochę nauczyć, ale nie mogłem nie zauważyć, że większość, jeśli nie wszystkie, używa wielu IFDEF i funkcji bezklasowych (gdzie mogły być członkami klasy/ metody). Przykładem jest kod źródłowy IDE Qt Creator: http://qt.gitorious.org/qt-creator/qt-creator/blobs/master/src/app/main.cpp Jeśli zauważysz, ma on kilka funkcji wokół główna funkcja; jednym z nich jest na przykład: static inline void toHtml(QString &t) powyższa metoda jest zdefiniowana na zewnątrz, podczas gdy myślę, że może być częścią jakiejś klasy użytkowej. Ponadto uważam, że IFDEF sprawiają, że programy są bałaganiarskie (znowu moja opinia). **Moje pytanie** : _czy jest to tylko przyjęta praktyka w świecie C++, aby mieszać kod proceduralny i kod OO w ten sposób?_


title: Dynamicznie ładująca się biblioteka MPL w aplikacji o zamkniętym kodzie źródłowym

text: Dynamicznie ładuję bibliotekę z licencją MPL 2.0, aby użyć niektórych jej wyeksportowanych funkcji w funkcji. Mój kod nie rozpowszechnia biblioteki, po prostu wykrywa jej obecność w systemie i używa jej, jeśli jest dostępna. Przejrzałem również kod źródłowy biblioteki, aby wyodrębnić funkcję i określone definicje typów. Jakie to ma konsekwencje dla mojego oprogramowania? Czy muszę rozpowszechniać MPL, część mojego kodu o otwartym kodzie źródłowym, która wykorzystuje wspomniane definicje typów, czy muszę wspomnieć o czymś w mojej umowie EULA itp.?


title: Budowanie wspólnej składni i struktury określania zakresu

text: Witajcie koledzy programiści, niedawno omawiałem projekt z kolegą i byłem ciekawy, co inni mają do powiedzenia lub czy coś takiego już istniało. ### Tło Istnieje wiele języków programowania. Istnieje wiele IDE i edytorów źródłowych, które podświetlają i edytują kod źródłowy. Idealne i dokładne przestrzeganie zasad języka w celu przedstawienia opcji autouzupełniania i zrozumienia zakresów w kodzie jest dość skomplikowane. To zadanie jest na tyle złożone, że większość IDE implementuje różne edytory źródeł jako wtyczki, które często ponownie implementują te same funkcje w kółko, ale w inny sposób (netbeans). Z tego, co mogę powiedzieć, większość IDE i edytorów źródłowych ponownie implementuje parsery, które używają wyrażeń regularnych lub jakiejś meta-składni Naur Form do ogólnego opisu gramatyki języków. Te parsery są implementowane w kółko. ### Pytanie Czy ktoś próbował ujednolicić lub opisać zestaw funkcji za pomocą API i mieć spójny interfejs do analizowania różnych języków programowania i dialektów. Nie opisuję IDE - ale spójne API dla dowolnego programu do użycia do analizowania i uzyskiwania metainformacji z kodu źródłowego. Zdaję sobie sprawę, że różne języki programowania oferują wiele różnych funkcji, które trudno „wyabstrahować” do zestawu funkcji, ale uważam, że byłoby to opłacalne przedsięwzięcie. Wydaje mi się, że może to pozwolić autorom tłumaczy ustnych na utrzymanie centralnego interpretatora gramatyki dla ich języka. podstawa Pythona mogłaby utrzymywać API dla gramatyków Pythona, ANSI API dla gramatyków C, Oracle API dla gramatyków Java itp. ### Przykładowe użycie Gdyby to było API, generatory dokumentacji kodu teoretycznie mogłyby działać we wszystkich dialektach i językach do pewnego poziomu. Nie miałoby znaczenia, czy Twój projekt używał 5 różnych języków, jedna aplikacja mogłaby udokumentować je wszystkie wraz z komentarzami i doc-tagami. Czy ktoś próbował tego kompleksowo?


title: Czy posiadanie tytułu magistra informatyki pomaga w Twojej karierze?

text: Jestem ciekawa doświadczeń programistów, którzy wyszli poza studia lub uniwersytety, a teraz pracują w branży. Nie mówię o akademii (i tak potrzebujesz doktoratu). Czy masz tytuł magistra? Czy pomogło to w Twojej karierze? Czy oprócz wiedzy, którą zdobywa się podczas studiów, są jakieś inne korzyści?


title: Jak odrzucić przegląd kodu, który uważasz za niepotrzebny?

text: Jestem w sytuacji, w której poproszono mnie o sprawdzenie kodu, który rozwiązuje problem, o którym nie wierzę. Fixer, który jest starszy ode mnie, upiera się, że jego poprawka jest konieczna, ale wydaje mi się, że jest to tylko sofistyka C++. Częścią naszego procesu wdrażania jest przegląd kodu i jako drugi co do wielkości inżynier w małej firmie powinienem dokonywać przeglądu zmian. Uważam, że recenzenci są tak samo odpowiedzialni za zmiany w kodzie, jak oryginalny koder, i nie chcę przyjmować odpowiedzialności za tę zmianę. Jak byś odrzucił tę recenzję?


title: 2 serwery 1 baza danych — czy mogę korzystać z Redis?

text: Ok mam tutaj kilka pytań. Najpierw podam kilka podstawowych informacji. Zaczynam projekt, w którym mam serwer node.js, na którym działa moja aplikacja, a moja witryna działa na innym normalnym serwerze. Moja aplikacja pozwoli wielu użytkownikom na jednoczesne połączenia i aktualizacje bazy danych, więc Redis wydawał się tam dobrze pasować ze względu na swoją szybkość i atomowe funkcje. Aby ktoś mógł uzyskać dostęp do mojej aplikacji, musi zalogować się na konto. Aby uzyskać konto, muszą zarejestrować się za pośrednictwem mojej strony internetowej. Więc moja strona internetowa potrzebuje bazy danych, ale nie jest ważne, aby mieć tutaj bazę danych taką jak Redis, ponieważ jej nie potrzebuje. Co prowadzi mnie do mojego pierwszego pytania: **1\. Czy Redis może być używany nawet bez node.js?** Wygląda na to, że byłoby wygodnie, gdyby oba moje serwery używały tej samej bazy danych do śledzenia informacji. W niektórych przypadkach będą śledzić te same informacje (jak w informacjach o użytkowniku), a w innych będą śledzić oddzielne informacje. Więc nawet jeśli witryna nie będzie w pełni wykorzystywać wszystkiego, co ma do zaoferowania Redis, wydaje się, że byłoby to wygodniejsze. Więc zakładając, że Redis może być użyty w tej sytuacji, prowadzi to do mojego następnego pytania: **2\. Skoro Redis jest połączony z JavaScript, jak poradziłbym sobie z bezpieczeństwem użytkowników mojej witryny?** Co powstrzymywałoby użytkowników mojej witryny przed otwarciem firebuga lub inspektora chrome i wprowadzaniem zmian w bazie danych? Może gdybym zaprojektował swoją stronę w takim układzie: apply.php->update.php->home.php. Gdzie po przesłaniu formularza przekieruje ich na stronę aktualizacji, na której uruchomi się JavaScript, a następnie przekieruje ich po aktualizacji bazy danych na stronę główną. Naprawdę nie wiem, czy w tym momencie robię zdjęcia w ciemności. :) Może lepszą alternatywą byłoby, gdyby moja aplikacja node.js miała dostęp do własnej bazy danych Redis, a także miała dostęp do innej bazy danych MySQL, do której również ma dostęp moja strona internetowa. A może istnieje inna baza danych, która lepiej sprawdziłaby się w tej sytuacji niż Redis. W każdym razie wszelkie wskazówki w tej sprawie byłyby bardzo mile widziane. :)


title: Specyficzne i ogólne zachowanie obiektów pochodnych, o których klient nie musi być świadomy

text: Mamy bazę danych z tabelami wykorzystującymi hierarchię dziedziczenia. Jednostka w tabeli pochodnej będzie miała identyfikator, który pasuje do jednostki w tabeli podstawowej i tak dalej w hierarchii. Mamy klasy repozytorium dla typów/tabel pochodnych, dzięki czemu można uzyskać konkretne instancje według ID. Problem, który mamy w tej chwili polega na tym, że chcemy mieć możliwość zastosowania określonego zachowania do niektórych encji, ale chcemy również zastosować pewne ogólne zachowanie do wszystkich encji bazowych. Dobrze by było, gdyby klient mógł potraktować zbiór encji jako encję bazową i po prostu wywołać metodę do wykonania na niej tej akcji, nie wiedząc o konkretnym zachowaniu. Czyli klient otrzyma z serwera zbiór encji, w tym ich ID. Klient następnie wywoła na serwerze metodę z niektórymi z tych identyfikatorów i jakoś serwer musi być w stanie stwierdzić, do jakich typów pochodnych należą identyfikatory. Rozważałem pozostawienie dziedziczenia tabeli na miejscu, aby dane nie były duplikowane, ale miały znacznik „typ” w tabeli podstawowej. Czy to pokonuje cel hierarchii dziedziczenia?


title: Wypełnij pola lub zwróć obiekt

text: **Co lepiej zrobić w tego typu scenariuszu: wypełnić pola czy zwrócić obiekt?** Sytuacja wygląda tak: wykonuję obliczenia, aby znaleźć ceny (z podatkiem, bez podatku, z rabatem itp.) produktu . Czy jest jakaś rada lub czy są jakieś wskazówki dotyczące obsługi wartości zwrotu? Wypełnij pola: public class ProductPrice { public int BasePrice; publiczne int IncTax; public int ExTax; // ... public void GetPricesForProduct(int ProductID) { /* Wypełnij pola na podstawie wyników */ } } Zwróć obiekt: public class PriceCalculator { public ProductPrice GetPricesForProduct(int ProductID) { /* Wypełnij pola obiektu i zwróć obiekt */ } } public class ProductPrice { public int BasePrice; publiczne int IncTax; public int ExTax; } Nie jestem pewien, czy naprawdę podoba mi się pierwsza metoda, ponieważ typ powrotu `void` nie wyjaśnia, co się stanie, gdy metoda zostanie wykonana. Jednak zwrócenie obiektu skutkuje powstaniem klasy, która nie ma żadnej funkcjonalności.


title: Inicjowanie właściwości, które nie są parametrami w konstruktorze: alternatywy

text: Klasa ładuje właściwości z pliku i używa ich podczas wykonywania swoich obowiązków. Do celów testowych chcę mieć możliwość bezpośredniego modyfikowania wspomnianych właściwości bez konieczności korzystania z pliku właściwości testowych. Zrobiłem implementację, ale wydaje się, że jest wypełniona zapachami - walczę z utrzymaniem tego małego (unikam frameworków, takich jak Spring, które zawijają i wstrzykują właściwości). W szczególności nie przypominam sobie, abym widział konstruktor, który inicjuje się za pomocą statycznie załadowanego zestawu właściwości — szczególnie, że ustawia wartości zmiennych z innego miejsca niż przekazane parametry. Szukam argumentów za/przeciw temu podejściu i mam nadzieję, że trafię na kilka alternatyw, jeśli jest to naprawdę tak niefajne, jak mi się wydaje. prywatny statyczny końcowy String CONFIG_FILE_NAME = String.format("config-%s.properties", null != System.getProperty("JAVA_ENV") ? System.getProperty("JAVA_ENV") : "development"); static { WŁAŚCIWOŚCI = nowe Właściwości(); spróbuj { PROPERTIES.load(MyClass.class.getClassLoader().getResourceAsStream(CONFIG_FILE_NAME)); if (PROPERTIES.keySet().size() < 1) { LOGGER.error(String.format("nie udało się załadować %s: brak właściwości", CONFIG_FILE_NAME)); } } catch (końcowy wyjątek IOException tj.) { LOGGER.error(String.format("nie udało się załadować %s", CONFIG_FILE_NAME), tj.); } } private String właściwość1; prywatna właściwość String2; public MojaKlasa() { property1 = PROPERTIES.getProperty("prop.1"); własność2 = WŁAŚCIWOŚCI.getProperty("właściwość2"); } /* publiczne akcesory dla property1 i property2 przejdź tutaj */


title: Skala ocen punktowych przekrzywiona

text: Używając pokera planistycznego do szacowania, otrzymaliśmy efektywną nieliniową skalę punktową. Rozumiem przez to, że wartość punktowa jest niespójna dla jednopunktowych i powiedzmy ośmiopunktowych. Po kilka przykładów: * 1 punkt: dodaj tekst podpowiedzi do kilku ikon; formatowanie ciągów daty i czasu * 3 punkty: utwórz nową rolę użytkownika i określ jego uprawnienia; automatycznie twórz nową sprawę w CRM po wykonaniu określonych czynności * 5 punktów: funkcjonalność listy obserwowanych; funkcja filtrowania w kilku aspektach * 8 punktów: integracja z zewnętrznym dostawcą *i* wprowadzenie warstwy trwałości do buforowania ich odpowiedzi Moje obawy są dwojakie: tracimy wierność szacowania, ograniczając się do najniższego poziomu skali i wszelkich raportowanie (lub obliczanie średniej prędkości) będzie błędne. Jak mogę zachęcić scrum mastera, właściciela produktu i zespół do stosowania bardziej spójnej, liniowej skali? **Edycja:** tylko dla wyjaśnienia, używamy jednej z tradycyjnych talii, która sięga aż do 100… z wyjątkiem tego, że jakoś zakotwiczyliśmy się, aby nie przekroczyć 5, co kończy się efektywnie skalą logarytmiczną.