Datasets:

beratcmn

/

lima-tr

like 2

Suppose I wrote that I will be killed by a UFO falling from space in the year 2315 while I am lifting. Will the Note increase my lifespan? In other words, will I still be alive by then?

Diyelim ki 2315 yılında ağırlık kaldırırken uzaydan düşen bir UFO tarafından öldürüleceğimi yazdım. Not ömrümü uzatır mı? Başka bir deyişle, o zamana kadar hala hayatta olacak mıyım?

No. There are some rules that prevent this. From the Rules of the Death Note wiki: 1. The 23-days rule How to use: XXVII * [...] * If you write, “die of disease” for the cause of death, but only write a specific time of death without the actual name of disease, the human will die from an adequate disease. But the Death Note can only operate within 23 days (in the human calendar). This is called the 23-day rule. 2. Situation/cause of death is impossible How to Use: LIV * [...] * In the occasion where the cause of death is possible but the situation is not, only the cause of death will take effect for that victim. If both the cause and the situation are impossible, that victim will die of heart attack. While an UFO falling on your head is technically unlikely, but not impossible, the fact that you'll be naturally alive by 2315 is impossible. You'll just shorten your life, not make it longer. 3. Setting death after original lifespan How to Use: LVII * In the Death Note, you cannot set the death date longer than the victim’s original life span. Even if the victim’s death is set in the Death Note beyond his/her original life span, the victim will die before the set time.

Hayır. Bunu engelleyen bazı kurallar var. Death Note wiki'sinin Kurallarından: 1. 23 günlük kural Nasıl kullanılır: XXVII * [...] * Ölüm nedeni olarak "hastalıktan öl" yazarsanız, ancak hastalığın gerçek adını yazmadan yalnızca belirli bir ölüm zamanı yazarsanız, insan uygun bir hastalıktan ölür. Ancak Death Note yalnızca 23 gün içinde (insan takviminde) çalışabilir. Buna 23 günlük kural denir. 2. Ölüm durumu/nedeni imkansızdır Nasıl Kullanılır: LIV * [...] * Ölüm nedeni mümkün ancak durum mümkün değilse, yalnızca ölüm nedeni o kurban için geçerli olacaktır. Hem neden hem de durum imkansızsa, o kurban kalp krizinden ölür. Başınıza bir UFO'nun düşmesi teknik olarak pek olası olmasa da imkansız değildir, 2315'te doğal olarak hayatta olacağınız gerçeği imkansızdır. Sadece ömrünüzü kısaltırsınız, uzatmazsınız. 3. Ölümü orijinal yaşam süresinden sonraya ayarlama Nasıl Kullanılır: LVII * Death Note'ta, ölüm tarihini kurbanın orijinal yaşam süresinden daha uzun bir süreye ayarlayamazsınız. Kurbanın ölümü Death Note'ta orijinal yaşam süresinden daha uzun bir süreye ayarlanmış olsa bile, kurban belirlenen zamandan önce ölür.

I have an Affa Protector enchanted with Unhallowed Pact ... My opponent kills my Affa with Dread Slaver ... Who will take control of the creature at the end? This is taking into consideration that my aura spell was cast 5 turns ago. Meaning my aura spell is NOT on the stack.

Unhallowed Pact ile büyülü bir Affa Protector'ım var... Rakibim Affa'mı Dread Slaver ile öldürüyor... Sonunda yaratığın kontrolünü kim alacak? Bu, aura büyümün 5 tur önce oynandığını göz önünde bulundurarak. Yani aura büyüm yığında DEĞİL.

It depends on whose turn it is. Both abilities trigger at the same time, and so will be put on the stack together. Abilities are put on the stack in APNAP (Active Player, Non-Active Player) order.* This means that the player whose turn it is puts their ability on the stack, then the other player does. That second player's ability will resolve first, returning the creature to the battlefield. When the other ability tries to resolve, it fails to find the creature in the graveyard and thus can't return it. Thus whoever's the active player won't end up with the creature. For multiplayer games where there are multiple NAPs they are put on the stack in turn order starting from the AP, so the last player in turn order with such an effect would take precedence. * From the rules on Triggered Abilities: > 603.3b If multiple abilities have triggered since the last time a player received priority, each player, in APNAP order, puts triggered abilities he or she controls on the stack in any order he or she chooses. [...] This works with any number of players, starting with the active player and passing around in turn order. In this case, the player furthest away from taking their turn (the last player to put their ability on the stack) would get the creature.

Sıra kimdeyse ona bağlıdır. Her iki yetenek de aynı anda tetiklenir ve bu nedenle yığına birlikte konur. Yetenekler yığına APNAP (Aktif Oyuncu, Aktif Olmayan Oyuncu) sırasıyla konur.* Bu, sırası olan oyuncunun yeteneğini yığına koyduğu, ardından diğer oyuncunun koyduğu anlamına gelir. İkinci oyuncunun yeteneği önce çözülür ve yaratığı savaş alanına geri döndürür. Diğer yetenek çözülmeye çalıştığında, yaratığı mezarlıkta bulamaz ve bu nedenle geri döndüremez. Bu nedenle, aktif oyuncu olan kişi yaratığı elde edemez. Birden fazla NAP'ın bulunduğu çok oyunculu oyunlarda, AP'den başlayarak sırayla yığına konurlar, bu nedenle böyle bir etkiye sahip olan sıradaki son oyuncu öncelik alır. * Tetiklenen Yetenekler kurallarından: > 603.3b Son kez bir oyuncu öncelik aldıktan sonra birden fazla yetenek tetiklendiyse, her oyuncu, APNAP sırasıyla, kontrol ettiği tetiklenen yetenekleri istediği sırayla yığına koyar. [...] Bu, aktif oyuncuyla başlayarak ve sırayla geçerek herhangi bir oyuncu sayısıyla çalışır. Bu durumda, sırasını almaktan en uzak oyuncu (yeteneğini yığına koyan son oyuncu) yaratığı alır.

I've found that some people call JavaScript a "dynamically, weakly typed" language, but some even say "untyped"? Which is it really?

Bazı kişilerin JavaScript'e "dinamik, zayıf tipli" bir dil dediğini, ancak bazılarının "tipsiz" dediğini gördüm. Gerçekten hangisi?

strong/weak can be thought of in relation to how the compiler, if applicable, handles typing. * Weakly typed means the compiler, if applicable, doesn't enforce correct typing. Without implicit compiler interjection, the instruction will error during run-time. ```"12345" * 1 === 12345 // string * number => number ``` Strongly typed means there is a compiler, and it wants you an explicit cast from string to integer. ```(int) "12345" * 1 === 12345 ``` In either case, some compiler's features can implicitly alter the instruction during compile-time to do conversions for you, if it can determine that is the right thing to do. Thus far, JavaScript can be categorized as Not-Strongly-Typed. That either means it's weakly-typed or un-typed. dynamic/static can be thought of in relation to how the language instructions manipulate types. * Dynamically typed means the value's type is enforced, but the variable simply represents any value of any type. ```x = 12345; // number x = "string"; // string x = { key: "value" }; // object y = 123 + x; // error or implicit conversion must take place. ``` Statically typed means the variable type is strongly enforced, and the value type is less-so enforced. ```int x = 12345; // binds x to the type int x = "string"; // too late, x is an integer - error string y = 123; // error or implicit conversion must take place. ``` Thus far, JavaScript can be categorized as Not-Statically-Typed. Also, it appears to be Dynamically Typed, if typed at all. So we need to see what Typing means. Typed means that the language distinguishes between different types such as string, number, boolean, object, array, null, undefined and so on. Also each operation is bound to specific types. So you cannot divide an integer by a string. ``` 2 / "blah" // produces NaN ``` Untyped means the operation of dividing integer by string would result in treating the first four bytes of string as integer. This is because Untyped operations take place directly on bits, there are no types to observe. The outcome will be something quite unexpected: ``` 2 / "blah" // will be treated as 2 / 1500275048 ``` Since JavaScript behaves according to the definition of being Typed, it must be. And therefore it must be Dynamically Typed, and Weakly Typed. If anybody claims JavaScript is Untyped, it is merely for academic theory, not for practical application.

Güçlü/zayıf, derleyicinin yazmayı nasıl işlediğine göre düşünülebilir. * Zayıf yazılmış, derleyici varsa doğru yazmayı zorlamaz demektir. Derleyicinin örtük müdahalesi olmadan, talimat çalışma zamanı sırasında hata verecektir. ```"12345" * 1 === 12345 // string * number => number ``` Güçlü yazılmış, bir derleyici olduğu ve dizgeden tam sayıya açık bir dönüştürme istediği anlamına gelir. ```(int) "12345" * 1 === 12345 ``` Her iki durumda da, bazı derleyicilerin özellikleri, doğru şeyin ne olduğunu belirleyebilirse, dönüştürmeleri sizin için yapmak üzere derleme zamanı sırasında talimatı örtük olarak değiştirebilir. Şimdiye kadar JavaScript, Güçlü Yazılmamış olarak sınıflandırılabilir. Bu, zayıf yazılmış veya yazılmamış olduğu anlamına gelir. Dinamik/statik, dil talimatlarının türleri nasıl işlediğine göre düşünülebilir. * Dinamik yazılmış, değerin türünün zorlandığı, ancak değişkenin herhangi bir türden herhangi bir değeri temsil ettiği anlamına gelir. ```x = 12345; // number x = "string"; // string x = { key: "value" }; // object y = 123 + x; // hata veya örtük dönüştürme gerçekleşmelidir. ``` Statik yazılmış, değişken türünün güçlü bir şekilde zorlandığı ve değer türünün daha az zorlandığı anlamına gelir. ```int x = 12345; // x'i int türüne bağlar x = "string"; // çok geç, x bir tam sayıdır - hata string y = 123; // hata veya örtük dönüştürme gerçekleşmelidir. ``` Şimdiye kadar JavaScript, Statik Yazılmamış olarak sınıflandırılabilir. Ayrıca, yazılmışsa Dinamik Yazılmış gibi görünmektedir. Bu yüzden Yazmanın ne anlama geldiğini görmemiz gerekiyor. Yazılmış, dilin dize, sayı, Boole değeri, nesne, dizi, null, tanımsız vb. gibi farklı türler arasında ayrım yaptığı anlamına gelir. Ayrıca her işlem belirli türlere bağlıdır. Bu nedenle bir tam sayıyı bir dizeye bölemezsiniz. ``` 2 / "blah" // NaN üretir ``` Yazılmamış, tam sayıyı dizeye bölme işleminin, dizenin ilk dört baytını tam sayı olarak ele almasıyla sonuçlanacağı anlamına gelir. Bunun nedeni, Yazılmamış işlemlerin doğrudan bitler üzerinde gerçekleşmesidir, gözlemlenecek tür yoktur. Sonuç oldukça beklenmedik bir şey olacaktır: ``` 2 / "blah" // 2 / 1500275048 olarak değerlendirilecektir ``` JavaScript, Yazılmış olmanın tanımına göre davrandığından, öyle olmalıdır. Ve bu nedenle Dinamik Yazılmış ve Zayıf Yazılmış olmalıdır. Birisi JavaScript'in Yazılmamış olduğunu iddia ediyorsa, bu yalnızca akademik teori içindir, pratik uygulama için değil.

I was fixing my laptop, and as you may know, laptops have a lot of small screws to take out when you are fixing it. One of the screws fell into the floor (the floor has carpet on it), and I was unable to follow the screw with my sight. If I don't follow the screw with my sight when it falls, there is a high chance that I will not see that screw again. My question is: what kind of method, tool or hack can I use to find small screws that falls into the floor? I have tried using the tool with a magnet on the tip, that mechanics use to grab wrenches that falls in inaccessible areas, but had no luck finding the screw.

Dizüstü bilgisayarımı tamir ediyordum ve bildiğiniz gibi dizüstü bilgisayarları tamir ederken çıkarılması gereken birçok küçük vida vardır. Vidaların biri yere düştü (yerde halı var) ve vidayı gözümle takip edemedim. Düştüğünde vidayı gözümle takip etmezsem, o vidayı bir daha görmeme ihtimali yüksek. Soru şu: Yere düşen küçük vidaları bulmak için ne tür bir yöntem, araç veya hile kullanabilirim? Ulaşılması zor alanlara düşen anahtarları almak için mekanikçilerin kullandığı uçta mıknatıs bulunan aleti kullanmayı denedim ama vidayı bulmakta şansım yaver gitmedi.

This is why you should always have spare screws on hand. Fortunately, there is a way: ## Light Method Most screws are silver. Shine a flashlight into the carpet and look for little silvery glints. This may take some time, but you'll probably find it. If your carpet is unnaturally thick... ## Magnet Method Take a powerful magnet (like a bar magnet, hardware stores - fridge magnets might work) and run it over the surface where you think the screw is. You should find it. If that still fails... ## Vacuum Method Take a good vacuum cleaner. Put a sock over the extending arm, and run it over where you think the screw is. The sock will prevent the screw from being vacuumed up, but it will be stuck to the sock. There will still be enough suction to pick up the screw, even with the sock. If not, get a new vacuum! If that fails... ## Organize your screws There are many useful tools to organize screws. Go to your local RadioShack and get one, or make one out of a magnet for that awesome lifehack feel. ## Stop using carpet! [Not a "find your screws" method - a tip about not frying your computer] Carpet can cause static discharge, which is very very very bad for a computer (personal experience). Work on a hard floor with an antistatic strap to reduce the chance of frying your PC.

Bu yüzden elinizde her zaman yedek vidalar bulundurmalısınız. Neyse ki bir yol var: ## Işık Yöntemi Çoğu vida gümüştür. Halıya bir el feneri tutun ve küçük gümüş parıltılar arayın. Bu biraz zaman alabilir, ancak muhtemelen bulacaksınız. Halınız doğal olmayan bir şekilde kalınsa... ## Mıknatıs Yöntemi Güçlü bir mıknatıs alın (çubuk mıknatıs gibi, nalburlar - buzdolabı mıknatısları işe yarayabilir) ve vidanın olduğunu düşündüğünüz yüzeyin üzerinden geçirin. Bulmalısınız. Bu da başarısız olursa... ## Elektrikli Süpürge Yöntemi İyi bir elektrikli süpürge alın. Uzatma kolunun üzerine bir çorap geçirin ve vidanın olduğunu düşündüğünüz yerin üzerinden geçirin. Çorap, vidanın elektrikli süpürgeyle çekilmesini önleyecek, ancak çoraba yapışacaktır. Çorapla bile vidayı alacak kadar emiş gücü olacaktır. Değilse, yeni bir elektrikli süpürge alın! Bu da başarısız olursa... ## Vidalarınızı düzenleyin Vidaları düzenlemek için birçok kullanışlı araç vardır. Yerel RadioShack'inize gidin ve bir tane alın veya o harika hayat tüyosu hissini yaşamak için bir mıknatıstan bir tane yapın. ## Halı kullanmayı bırakın! ["Vidalarınızı bulun" yöntemi değil - bilgisayarınızı kızartmamakla ilgili bir ipucu] Halı, bir bilgisayar için çok çok çok kötü olan statik deşarjına neden olabilir (kişisel deneyim). Bilgisayarınızı kızartma şansını azaltmak için antistatik bir kayışla sert bir zemin üzerinde çalışın.

What is the difference between mutex and critical section? Please explain from Linux, Windows perspectives? I am programming in C#, would these two terms make a difference. Please post as much as you can, with examples and such.... Thanks

Mutex ve kritik bölüm arasındaki fark nedir? Lütfen Linux, Windows perspektiflerinden açıklayın? C# ile programlama yapıyorum, bu iki terim bir fark yaratır mı? Lütfen mümkün olduğunca çok örnek ve benzeri ile gönderin.... Teşekkürler

From a theoretical perspective, a critical section is a piece of code that must not be run by multiple threads at once because the code accesses shared resources. * A mutex is an algorithm (and sometimes the name of a data structure) that is used to protect critical sections. * Semaphores and Monitors are common implementations of a mutex. In practice there are many mutex implementation availiable in windows. They mainly differ as consequence of their implementation by their level of locking, their scopes, their costs, and their performance under different levels of contention. Availiable synchronization primitives. * Monitor * Mutex * Semaphore * ReaderWriterLock * ReaderWriterLockSlim * Interlocked The ```lock(object)``` statement is implemented using a ```Monitor``` - see MSDN for reference. In the last years much research is done on non-blocking synchronization. The goal is to implement algorithms in a lock-free or wait-free way. In such algorithms a process helps other processes to finish their work so that the process can finally finish its work. In consequence a process can finish its work even when other processes, that tried to perform some work, hang. Usinig locks, they would not release their locks and prevent other processes from continuing.

Teorik bir bakış açısından, kritik bir bölüm, paylaşılan kaynaklara erişen kod olduğundan birden fazla iş parçacığı tarafından aynı anda çalıştırılmaması gereken bir kod parçasıdır. * Bir mutex, kritik bölümleri korumak için kullanılan bir algoritmadır (ve bazen bir veri yapısının adıdır). * Semaforlar ve Monitörler, bir mutex'in yaygın uygulamalarıdır. Uygulamada, Windows'ta birçok mutex uygulaması mevcuttur. Bunlar esas olarak uygulama sonuçlarına, kilitleme düzeylerine, kapsamlarına, maliyetlerine ve farklı çekişme düzeyleri altındaki performanslarına göre farklılık gösterir. Kullanılabilir eşitleme ilkellikleri. * Monitör * Mutex * Semafor * ReaderWriterLock * ReaderWriterLockSlim * Interlocked ```lock(object)``` ifadesi bir ```Monitor``` kullanılarak uygulanır - referans için MSDN'e bakın. Son yıllarda, engelleyici olmayan eşitleme üzerine birçok araştırma yapılmıştır. Amaç, algoritmaları kilitsiz veya beklemesiz bir şekilde uygulamaktır. Bu tür algoritmalarda bir işlem, diğer işlemlerin çalışmalarını bitirmelerine yardımcı olur, böylece işlem nihayetinde işini bitirebilir. Sonuç olarak, bir işlem, bazı işleri gerçekleştirmeye çalışan diğer işlemler askıda kalsa bile işini bitirebilir. Kilitleri kullanarak, kilitlerini serbest bırakmazlar ve diğer işlemlerin devam etmesini engellerler.

What is the purpose of the single underscore "_" variable in Python? What is the meaning of ```_``` after ```for``` in this code? ```if tbh.bag: n = 0 for _ in tbh.bag.atom_set(): n += 1 ```

Python'da tekli alt çizgi "_" değişkeninin amacı nedir? Bu kodda ```for``` ifadesinden sonra ```_``` ifadesinin anlamı nedir? ```if tbh.bag: n = 0 for _ in tbh.bag.atom_set(): n += 1 ```

```_``` has 3 main conventional uses in Python: 1. To hold the result of the last executed expression in an interactive interpreter session (see docs). This precedent was set by the standard CPython interpreter, and other interpreters have followed suit. 2. For translation lookup in i18n (see the gettext documentation for example), as in code like ```raise forms.ValidationError(_("Please enter a correct username")) ``` 3. As a general purpose "throwaway" variable name: * To indicate that part of a function result is being deliberately ignored (Conceptually, it is being discarded.), as in code like: ```label, has_label, _ = text.partition(':') ``` * As part of a function definition (using either ```def``` or ```lambda```), where the signature is fixed (e.g. by a callback or parent class API), but this particular function implementation doesn't need all of the parameters, as in code like: ```def callback(_): return True ``` This use case can conflict with the translation lookup use case, so it is necessary to avoid using ```_``` as a throwaway variable in any code block that also uses it for i18n translation (many folks prefer a double-underscore, ```__```, as their throwaway variable for exactly this reason). Linters often recognize this use case. For example ```year, month, day = date()``` will raise a lint warning if ```day``` is not used later in the code. The fix, if ```day``` is truly not needed, is to write ```year, month, _ = date()```. Same with lambda functions, ```lambda arg: 1.0``` creates a function requiring one argument but not using it, which will be caught by lint. The fix is to write ```lambda _: 1.0```. An unused variable is often hiding a bug/typo (e.g. set ```day``` but use ```dya``` in the next line). The pattern matching feature added in Python 3.10 elevated this usage from "convention" to "language syntax" where ```match``` statements are concerned: in match cases, ```_``` is a wildcard pattern, and the runtime doesn't even bind a value to the symbol in that case. For other use cases, remember that ```_``` is still a valid variable name, and hence will still keep objects alive. In cases where this is undesirable (e.g. to release memory or external resources) an explicit ```del name``` call will both satisfy linters that the name is being used, and promptly clear the reference to the object.

```_``` Python'da 3 ana geleneksel kullanım amacı vardır: 1. Etkileşimli bir yorumlayıcı oturumunda en son yürütülen ifadenin sonucunu tutmak (belgelere bakın). Bu emsal, standart CPython yorumlayıcısı tarafından belirlenmiştir ve diğer yorumlayıcılar da bu örneği takip etmiştir. 2. i18n'de çeviri araması için (örneğin gettext belgelerine bakın), aşağıdaki kodda olduğu gibi: ```raise forms.ValidationError(_("Please enter a correct username")) ``` 3. Genel amaçlı "tek kullanımlık" değişken adı olarak: * Bir fonksiyon sonucunun bir kısmının kasıtlı olarak göz ardı edildiğini belirtmek için (Kavramsal olarak, atılıyor.), aşağıdaki kodda olduğu gibi: ```label, has_label, _ = text.partition(':') ``` * İmzanın sabitlendiği (ör. bir geri çağırma veya üst sınıf API tarafından) bir fonksiyon tanımının parçası olarak (```def``` veya ```lambda``` kullanılarak), ancak bu belirli fonksiyon uygulamasının tüm parametrelere ihtiyacı olmadığı durumlarda, aşağıdaki kodda olduğu gibi: ```def callback(_): return True ``` Bu kullanım durumu, çeviri araması kullanım durumu ile çakışabilir, bu nedenle ```_```'yi i18n çevirisi için de kullanan herhangi bir kod bloğunda tek kullanımlık değişken olarak kullanmaktan kaçınmak gerekir (birçok kişi tam da bu nedenle tek kullanımlık değişkenleri olarak çift alt çizgi, ```__```'yi tercih eder). Lintleyiciler genellikle bu kullanım durumunu tanır. Örneğin ```year, month, day = date()```, ```day``` daha sonra kodda kullanılmazsa bir lint uyarısı verecektir. ```day``` gerçekten gerekmiyorsa düzeltme, ```year, month, _ = date()``` yazmaktır. Aynı şey lambda fonksiyonları için de geçerlidir, ```lambda arg: 1.0```, bir argüman gerektiren ancak kullanmayan bir fonksiyon oluşturur ve bu lint tarafından yakalanır. Düzeltme, ```lambda _: 1.0``` yazmaktır. Kullanılmayan bir değişken genellikle bir hatayı/yazım yanlışı gizler (ör. ```day```'i ayarlayın ancak sonraki satırda ```dya``` kullanın). Python 3.10'da eklenen desen eşleştirme özelliği, bu kullanımı "sözleşme"den "dil sözdizimi"ne yükseltti ve ```match``` ifadeleri söz konusu olduğunda ```_``` bir joker desendir ve çalışma zamanı bu durumda sembole bir değer bile bağlamaz. Diğer kullanım durumları için, ```_```'nin hala geçerli bir değişken adı olduğunu ve bu nedenle nesneleri canlı tutacağını unutmayın. Bunun istenmediği durumlarda (ör. bellek veya harici kaynakları serbest bırakmak için) açık bir ```del name``` çağrısı, hem lintleyicileri adın kullanıldığı konusunda tatmin edecek hem de nesneye olan referansı derhal temizleyecektir.

What is the difference between doing: ```ptr = malloc (MAXELEMS * sizeof(char *)); ``` or: ```ptr = calloc (MAXELEMS, sizeof(char*)); ``` When is it a good idea to use calloc over malloc or vice versa?

Aşağıdakiler arasındaki fark nedir: ```ptr = malloc (MAXELEMS * sizeof(char *)); ``` veya: ```ptr = calloc (MAXELEMS, sizeof(char*)); ``` Calloc'u malloc'un yerine kullanmak için iyi bir zaman ne zamandır veya tam tersi?

```calloc()``` gives you a zero-initialized buffer, while ```malloc()``` leaves the memory uninitialized. For large allocations, most ```calloc``` implementations under mainstream OSes will get known-zeroed pages from the OS (e.g. via POSIX ```mmap(MAP_ANONYMOUS)``` or Windows ```VirtualAlloc```) so it doesn't need to write them in user-space. This is how normal ```malloc``` gets more pages from the OS as well; ```calloc``` just takes advantage of the OS's guarantee. This means ```calloc``` memory can still be "clean" and lazily-allocated, and copy-on-write mapped to a system-wide shared physical page of zeros. (Assuming a system with virtual memory.) The effects are visible with performance experiments on Linux, for example. Some compilers even can optimize malloc + memset(0) into calloc for you, but it's best to just use calloc in the source if you want zeroed memory. (Or if you were trying to pre-fault it to avoid page faults later, that optimization will defeat your attempt.) If you aren't going to ever read memory before writing it, use ```malloc``` so it can (potentially) give you dirty memory from its internal free list instead of getting new pages from the OS. (Or instead of zeroing a block of memory on the free list for a small allocation). Embedded implementations of ```calloc``` may leave it up to ```calloc``` itself to zero memory if there's no OS, or it's not a fancy multi-user OS that zeros pages to stop information leaks between processes. On embedded Linux, malloc could ```mmap(MAP_UNINITIALIZED|MAP_ANONYMOUS)```, which is only enabled for some embedded kernels because it's insecure on a multi-user system.

```calloc()``` size sıfırlanmış bir arabellek verirken, ```malloc()``` belleği sıfırlanmamış bırakır. Büyük tahsisler için, ana akım işletim sistemlerindeki çoğu ```calloc``` uygulaması işletim sisteminden bilinen sıfırlanmış sayfalar alır (ör. POSIX ```mmap(MAP_ANONYMOUS)``` veya Windows ```VirtualAlloc``` yoluyla), bu nedenle bunları kullanıcı alanına yazması gerekmez. Normal ```malloc```'un işletim sisteminden daha fazla sayfa alması da böyle olur; ```calloc``` yalnızca işletim sisteminin garantisinden yararlanır. Bu, ```calloc``` belleğinin hala "temiz" ve tembelce tahsis edilebileceği ve sıfırların sistem çapında paylaşılan fiziksel bir sayfasına kopyalanarak eşlenen anlamına gelir. (Sanal belleğe sahip bir sistem varsayarak.) Etkiler, örneğin Linux'ta performans deneyleriyle görülebilir. Bazı derleyiciler hatta sizin için malloc + memset(0)'ı calloc'a optimize edebilir, ancak sıfırlanmış bellek istiyorsanız kaynakta calloc kullanmak en iyisidir. (Veya daha sonra sayfa hatalarından kaçınmak için önceden hata yapmak istiyorsanız, bu optimizasyon girişiminizi bozacaktır.) Belleği yazmadan önce asla okumayacaksanız, işletim sisteminden yeni sayfalar almak yerine dahili serbest listesinden (potansiyel olarak) size kirli bellek verebilmesi için ```malloc``` kullanın. (Veya küçük bir tahsis için serbest listede bir bellek bloğunu sıfırlamak yerine). ```calloc```'un gömülü uygulamaları, işletim sistemi yoksa veya işlemler arasında bilgi sızıntılarını durdurmak için sayfaları sıfırlayan süslü bir çok kullanıcılı işletim sistemi değilse, belleği sıfırlamak için ```calloc```'un kendisine bırakabilir. Gömülü Linux'ta, malloc yalnızca bazı gömülü çekirdekler için etkinleştirilmiş olan ```mmap(MAP_UNINITIALIZED|MAP_ANONYMOUS)```'u kullanabilir, çünkü çok kullanıcılı bir sistemde güvenli değildir.

Why would I want to use Kotlin's coroutines? It seems that the RxKotlin library is much more versatile. Kotlin's coroutines look significantly less powerful and more cumbersome to use in comparison. I base my opinion on coroutines on this design talk by Andrey Breslav (JetBrains) Slideshow from the talk is accessible here.

Neden Kotlin'in coroutine'lerini kullanmak isteyeyim? RxKotlin kütüphanesi çok daha çok yönlü görünüyor. Kotlin'in coroutine'leri karşılaştırıldığında çok daha az güçlü ve kullanımı daha zahmetli görünüyor. Coroutine'ler hakkındaki fikrimi Andrey Breslav'ın (JetBrains) verdiği bu tasarım konuşmasına dayandırıyorum. Konuşmanın slayt gösterisine buradan ulaşılabilir.

Kotlin coroutines are different from Rx. It is hard to compare them apples-to-apples, because Kotlin coroutines are a thin language feature (with just a couple of basic concepts and a few basic functions to manipulate them), while Rx is a pretty heavy library with quite large variety of ready-to-use operators. Both are designed to address a problem of asynchronous programming, however their approach to solution is very different: * Rx comes with a particular functional style of programming that can be implemented in virtually any programming language without support from the language itself. It works well when the problem at hand easily decomposes into a sequence of standard operators and not so well otherwise. * Kotlin coroutines provide a language feature that let library writers implement various asynchronous programming styles, including, but not limited to functional reactive style (Rx). With Kotlin coroutines you can also write your asynchronous code in imperative style, in promise/futures-based style, in actor-style, etc. It is more appropriate to compare Rx with some specific libraries that are implemented based on Kotlin coroutines. Take kotlinx.coroutines library as one example. This library provides a set of primitives like ```async/await``` and channels that are typically baked into other programming languages. It also has support for light-weight future-less actors. You can read more in the Guide to kotlinx.coroutines by example. Channels provided by ```kotlinx.coroutines``` can replace or augment Rx in certain use-cases. There is a separate Guide to reactive streams with coroutines that goes deeper into similarities and differences with Rx.

Kotlin coroutine'leri Rx'ten farklıdır. Bunları birebir karşılaştırmak zordur çünkü Kotlin coroutine'leri ince bir dil özelliğidir (sadece birkaç temel kavram ve bunları işlemek için birkaç temel işlevle) Rx ise oldukça fazla çeşitlilikte kullanıma hazır operatör içeren oldukça ağır bir kütüphanedir. İkisi de asenkron programlama sorununu ele almak için tasarlanmıştır ancak çözüme yaklaşımları çok farklıdır: * Rx, dilin kendisinden destek almadan hemen hemen her programlama dilinde uygulanabilen belirli bir fonksiyonel programlama stiliyle birlikte gelir. Mevcut sorun standart operatörler dizisine kolayca ayrıştırıldığında iyi çalışır, aksi takdirde pek iyi çalışmaz. * Kotlin coroutine'leri, kütüphane yazarlarının fonksiyonel reaktif stil (Rx) dahil ancak bununla sınırlı olmamak üzere çeşitli asenkron programlama stillerini uygulamasına olanak tanıyan bir dil özelliği sağlar. Kotlin coroutine'leri ile asenkron kodunuzu zorunlu stilde, söz/gelecek tabanlı stilde, aktör stilinde vb. de yazabilirsiniz. Rx'i, Kotlin coroutine'lerine dayanarak uygulanan bazı belirli kütüphanelerle karşılaştırmak daha uygundur. Örnek olarak kotlinx.coroutines kütüphanesini ele alalım. Bu kütüphane, tipik olarak diğer programlama dillerine dahil edilmiş ```async/await``` ve kanallar gibi bir dizi ilkel sağlar. Ayrıca hafif geleceksiz aktörler için destek içerir. Örneklerle kotlinx.coroutines Kılavuzu'nda daha fazla bilgi edinebilirsiniz. ```kotlinx.coroutines``` tarafından sağlanan kanallar, belirli kullanım durumlarında Rx'in yerini alabilir veya onu artırabilir. Rx ile benzerlikleri ve farklılıkları daha derinlemesine ele alan coroutine'leri içeren reaktif akışlara yönelik ayrı bir Kılavuz vardır.

How do I get a ```PriorityQueue``` to sort on what I want it to sort on? Also, is there a difference between the ```offer``` and ```add``` methods?

Bir ```PriorityQueue```'in neye göre sıralanmasını istediğime göre sıralamasını nasıl sağlayabilirim? Ayrıca, ```offer``` ve ```add``` yöntemleri arasında bir fark var mı?

## Java 8 solution We can use ```lambda expression``` or ```method reference``` introduced in Java 8. In case we have some String values stored in the Priority Queue (having capacity 5) we can provide inline comparator (based on length of String) : Using lambda expression ```PriorityQueue pq= new PriorityQueue(5,(a,b) -> a.length() - b.length()); ``` Using Method reference ```PriorityQueue pq= new PriorityQueue(5, Comparator.comparing(String::length)); ``` Then we can use any of them as: ```public static void main(String[] args) { PriorityQueue pq= new PriorityQueue(5, (a,b) -> a.length() - b.length()); // or pq = new PriorityQueue(5, Comparator.comparing(String::length)); pq.add("Apple"); pq.add("PineApple"); pq.add("Custard Apple"); while (pq.size() != 0) { System.out.println(pq.remove()); } } ``` This will print: ```Apple PineApple Custard Apple ``` To reverse the order (to change it to max-priority queue) simply change the order in inline comparator or use ```reversed``` as: ```PriorityQueue pq = new PriorityQueue(5, Comparator.comparing(String::length).reversed()); ``` We can also use ```Collections.reverseOrder```: ```PriorityQueue pqInt = new PriorityQueue(10, Collections.reverseOrder()); PriorityQueue pq = new PriorityQueue(5, Collections.reverseOrder(Comparator.comparing(String::length)) ``` So we can see that ```Collections.reverseOrder``` is overloaded to take comparator which can be useful for custom objects. The ```reversed``` actually uses ```Collections.reverseOrder```: ```default Comparator reversed() { return Collections.reverseOrder(this); } ``` offer() vs add() As per the doc > The offer method inserts an element if possible, otherwise returning false. This differs from the Collection.add method, which can fail to add an element only by throwing an unchecked exception. The offer method is designed for use when failure is a normal, rather than exceptional occurrence, for example, in fixed-capacity (or "bounded") queues. When using a capacity-restricted queue, offer() is generally preferable to add(), which can fail to insert an element only by throwing an exception. And PriorityQueue is an unbounded priority queue based on a priority heap.

## Java 8 çözümü Java 8'de tanıtılan ```lambda ifadesini``` veya ```metot referansını``` kullanabiliriz. Öncelik Kuyruğunda (5 kapasiteli) depolanan bazı String değerlerimiz varsa, satır içi karşılaştırıcı (String uzunluğuna göre) sağlayabiliriz: Lambda ifadesini kullanma ```PriorityQueue pq= new PriorityQueue(5,(a,b) -> a.length() - b.length()); ``` Metot referansını kullanma ```PriorityQueue pq= new PriorityQueue(5, Comparator.comparing(String::length)); ``` Sonra bunları şu şekilde kullanabiliriz: ```public static void main(String[] args) { PriorityQueue pq= new PriorityQueue(5, (a,b) -> a.length() - b.length()); // veya pq = new PriorityQueue(5, Comparator.comparing(String::length)); pq.add("Apple"); pq.add("PineApple"); pq.add("Custard Apple"); while (pq.size() != 0) { System.out.println(pq.remove()); } } ``` Bu şu şekilde yazdırır: ```Apple PineApple Custard Apple ``` Sırayı tersine çevirmek için (maksimum öncelikli kuyruğa çevirmek için) satır içi karşılaştırıcıdaki sırayı değiştirin veya ```reversed``` kullanın: ```PriorityQueue pq = new PriorityQueue(5, Comparator.comparing(String::length).reversed()); ``` ```Collections.reverseOrder``` kullanabiliriz: ```PriorityQueue pqInt = new PriorityQueue(10, Collections.reverseOrder()); PriorityQueue pq = new PriorityQueue(5, Collections.reverseOrder(Comparator.comparing(String::length)) ``` Yani ```Collections.reverseOrder```'ın özel nesneler için kullanışlı olabilecek karşılaştırıcıyı almak için aşırı yüklendiğini görebiliriz. ```reversed``` aslında ```Collections.reverseOrder``` kullanır: ```default Comparator reversed() { return Collections.reverseOrder(this); } ``` offer() ve add() Belgeye göre > offer metodu mümkünse bir eleman ekler, aksi takdirde false döndürür. Bu, yalnızca işaretlenmemiş bir istisna atarak bir eleman eklemeyi başaramayan Collection.add metodundan farklıdır. offer metodu, başarısızlığın normal bir durum olduğu, örneğin sabit kapasiteli (veya "sınırlı") kuyruklarda kullanılmak üzere tasarlanmıştır. Kapasitesi kısıtlı bir kuyruk kullanırken, yalnızca bir istisna atarak bir eleman eklemeyi başaramayan add()'ye göre offer() genellikle daha iyidir. Ve PriorityQueue, bir öncelik yığınına dayalı sınırsız bir öncelik kuyruğudur.

I've looked in the Apex developer's guide and a saw the Naming Conventions section which has basically only has this: We recommend following Java standards for naming, that is, classes start with a capital letter, methods start with a lowercase verb, and variable names should be meaningful. I'm looking for something more in depth, such as end all Controllers with Controller and their tests with ControllerTest, etc. What is a good set of naming conventions to use when developing on the Force.com platofrm? It would be preferable if the answer has something that handles custom objects, classes, visualforce pages, and components and not just Apex classes.

Apex geliştirici kılavuzuna baktım ve temelde sadece şunları içeren İsimlendirme Kuralları bölümünü gördüm: İsimlendirme için Java standartlarını takip etmenizi öneririz, yani sınıflar büyük harfle başlar, yöntemler küçük harfle başlayan bir fiille başlar ve değişken adları anlamlı olmalıdır. Controller ile tüm Denetleyicileri ve ControllerTest ile testlerini sonlandırmak gibi daha derinlemesine bir şey arıyorum. Force.com platformunda geliştirirken kullanılacak iyi bir isimlendirme kuralları kümesi nedir? Cevabın özel nesneleri, sınıfları, visualforce sayfalarını ve bileşenleri ele alan ve sadece Apex sınıflarını ele almayan bir şey içermesi tercih edilir.

Follow the CamelCase Java conventions, except for VF pages and components start with a lower case letter. Triggers: * <ObjectName>Trigger - The trigger itself. One per object. * <ObjectName>TriggerHandler - Class that handles all functionality of the trigger * <ObjectName>TriggerTest Controllers: * <ClassName>Controller * <ClassName>ControllerExt * <ClassName>ControllerTest * <ClassName>ControllerExtTest Classes: * <ClassName> * <ClassName>Test (These might be Util classes or Service classes or something else). Visualforce pages and components: * <ControllerClassName>[optionalDescription] (without the suffix Controller). There might be multiple views so could also have an extra description suffix. Object Names and custom Fields * Upper_Case_With_Underscores Variables/properties/methods in Apex * camelCaseLikeJava - more easily differentiated from fields Test methods in test classes * test<methodOrFunctionalityUnderTest><ShortTestCaseDesc> - For example, testSaveOpportunityRequiredFieldsMissing, testSaveOpportunityRequiredFieldsPresent, etc. Working on something that would be used as an app or in some cases just a project? If yes, then do the following: Prefix all custom objects, apex classes, Visualforce pages and components with an abbreviation so that they are easier to identify (e.g., easier for changesets). For example the WidgetFactory app would have the prefix wf on those. Additionally, when adding custom fields to a standard object they would also be prefixed to identify them as part of the app/package. The main reason for the Object and Fields Names using Upper_Case_With_Underscores is that when you type in the name field or object with spaces it automatically adds the underscores. Although Apex is case insensitive, always refer to the Objects and Custom Fields in the code as Upper_Case_With_Underscores as well for consistency all around and consistency with what is generated by the SOQL schema browser and other tools. Object and Field Labels (which are generally ignored by code but visible to users) should keep spaces, not underscores.

VF sayfaları ve bileşenleri hariç olmak üzere CamelCase Java kurallarına uyun, bunlar küçük harfle başlar. Tetikleyiciler: * <ObjectName>Trigger - Tetikleyicinin kendisi. Nesne başına bir tane. * <ObjectName>TriggerHandler - Tetikleyicinin tüm işlevselliğini işleyen sınıf * <ObjectName>TriggerTest Denetleyiciler: * <ClassName>Controller * <ClassName>ControllerExt * <ClassName>ControllerTest * <ClassName>ControllerExtTest Sınıflar: * <ClassName> * <ClassName>Test (Bunlar Yardımcı sınıflar veya Hizmet sınıfları veya başka bir şey olabilir). Visualforce sayfaları ve bileşenleri: * <ControllerClassName>[isteğe bağlıAçıklama] (Controller son eki olmadan). Birden fazla görünüm olabileceğinden ek bir açıklama son eki de olabilir. Nesne Adları ve özel Alanlar * Upper_Case_With_Underscores Apex'teki değişkenler/özellikler/yöntemler * camelCaseLikeJava - alanlardan daha kolay ayırt edilebilir Test sınıflarındaki test yöntemleri * test<methodOrFunctionalityUnderTest><ShortTestCaseDesc> - Örneğin, testSaveOpportunityRequiredFieldsMissing, testSaveOpportunityRequiredFieldsPresent, vb. Bir uygulama olarak veya bazı durumlarda yalnızca bir proje olarak kullanılacak bir şey üzerinde mi çalışıyorsunuz? Evet ise aşağıdakileri yapın: Tüm özel nesnelerin, apex sınıflarının, Visualforce sayfalarının ve bileşenlerinin önüne, bunları daha kolay tanımlayabilmek için bir kısaltma ekleyin (örneğin, değişiklik kümeleri için daha kolay). Örneğin, WidgetFactory uygulamasının bunların üzerinde wf öneki olacaktır. Ayrıca, standart bir nesneye özel alanlar eklerken, bunlar da uygulama/paketin bir parçası olarak tanımlanmak üzere ön ek alacaktır. Nesne ve Alan Adlarının Upper_Case_With_Underscores kullanmasının temel nedeni, ad alanına veya nesneye boşluklarla yazdığınızda otomatik olarak alt çizgiler eklemesidir. Apex büyük/küçük harfe duyarlı olmasa da, tutarlılık ve SOQL şema tarayıcısı ve diğer araçlar tarafından oluşturulanlarla tutarlılık için Nesneler ve Özel Alanlara her zaman Upper_Case_With_Underscores olarak başvurun. Nesne ve Alan Etiketleri (genellikle kod tarafından göz ardı edilir ancak kullanıcılar tarafından görülebilir) boşlukları korumalı, alt çizgi içermemelidir.

When learning some basic French, I was somewhat surprised to learn that phrases of the form "I have found the cat" generally translate almost word-for-word from English (J'ai trouvé le chat). To me, it's not immediately obvious that possession ("I have"/"J'ai") has a correspondence with past tense, although if I think about it a little more I suppose I can kind of see how it makes sense. This makes me wonder: Is this a common pattern in other languages? Especially ones not closely related to English.

Temel Fransızca öğrenirken, "Kedimi buldum" biçimindeki ifadelerin genellikle İngilizceden neredeyse kelimesi kelimesine çevrildiğini öğrenince biraz şaşırdım (J'ai trouvé le chat). Bana göre, sahiplik ("I have"/"J'ai") ile geçmiş zaman arasında bir karşılıklılık olduğu hemen belli değil, ancak biraz daha düşünürsem bunun nasıl mantıklı olduğunu anlayabilirim. Bu beni meraklandırıyor: Bu, diğer dillerde yaygın bir kalıp mı? Özellikle İngilizceyle yakından ilişkili olmayanlar.

This is what's called a "Sprachbund" feature: it's a trait shared by a bunch of languages in an area, even ones that aren't genetically related. In particular, this one is a feature of the "Standard Average European" Sprachbund, a group of languages centered in Western Europe, and it's one of the features that was originally used to define that Sprachbund in the first place! The construction seems to have arisen back in Latin. In Classical Latin, past aoristic verbs ("I loved") and present perfective verbs ("I have loved") look exactly the same: both of those would be written amāvī. But it's a pretty useful distinction to be able to make! So in Vulgar Latin, a new construction arose, using the verb habēre ("to have"). It's thought that a phrase like habeō litterās scriptās "I have (written letters)" got reanalyzed into "I (have written) letters", with habēre no longer indicating that you're actually holding anything in your hands, just that an action's been completed in the past. Vulgar Latin eventually evolved into French, Italian, Spanish, and all the other Romance languages, and brought this construction with it; habēre is the direct ancestor of French avoir, via a series of sound changes. And once various Romance languages and Germanic languages and others were all being spoken in the same area, this feature spread through the Sprachbund: people speaking Germanic languages started to use the same construction. English "have"/German haben/etc isn't actually at all related to Latin habēre, but they looked similar, so it was the obvious choice when adopting the construction into Germanic. Nowadays, this feature is called the "have-perfective", and it shows up in all sorts of languages within the Standard Average European (SAE) Sprachbund. It's not at all universal, but can be a good way to determine if a language has been influenced by SAE or not!

Buna "Sprachbund" özelliği denir: Bir bölgedeki bir grup dilin, genetik olarak ilişkili olmasalar bile paylaştığı bir özelliktir. Özellikle bu, Batı Avrupa'da merkezlenmiş bir grup dil olan "Standart Ortalama Avrupa" Sprachbund'unun bir özelliğidir ve ilk etapta bu Sprachbund'u tanımlamak için kullanılan özelliklerden biridir! Yapının Latince'de ortaya çıktığı görülüyor. Klasik Latince'de geçmiş aorist fiiller ("sevdim") ve şimdiki tamamlanmış fiiller ("sevdim") tam olarak aynı görünür: Bunların ikisi de amāvī olarak yazılır. Ancak yapabilmek için oldukça kullanışlı bir ayrımdır! Bu nedenle Vulgar Latince'de, habēre ("sahip olmak") fiilini kullanan yeni bir yapı ortaya çıktı. Habeō litterās scriptās "Sahip olduğum (yazılı mektuplar)" gibi bir ifadenin "Mektuplar (yazdım)" olarak yeniden analiz edildiği, habēre'nin artık elinizde bir şey tuttuğunuzu değil, geçmişte bir eylemin tamamlandığını gösterdiği düşünülmektedir. Vulgar Latince sonunda Fransızca, İtalyanca, İspanyolca ve diğer tüm Roman dillerine dönüştü ve bu yapıyı da beraberinde getirdi; habēre, bir dizi ses değişikliği yoluyla Fransızca avoir'in doğrudan atasıdır. Ve çeşitli Roman dilleri, Cermen dilleri ve diğerleri aynı bölgede konuşulmaya başlayınca, bu özellik Sprachbund'a yayıldı: Cermen dilleri konuşan insanlar aynı yapıyı kullanmaya başladı. İngilizce "have"/Almanca haben/vb. aslında Latince habēre ile hiç ilgili değildir, ancak benzer görünüyorlardı, bu nedenle yapıyı Cermen diline uyarlarken açık bir seçimdi. Günümüzde bu özelliğe "have-perfective" denir ve Standart Ortalama Avrupa (SAE) Sprachbund'u içindeki her türlü dilde ortaya çıkar. Hiç de evrensel değildir, ancak bir dilin SAE'den etkilenip etkilenmediğini belirlemenin iyi bir yolu olabilir!

I'm building a simple helper script for work that will copy a couple of template files in our code base to the current directory. I don't, however, have the absolute path to the directory where the templates are stored. I do have a relative path from the script but when I call the script it treats that as a path relative to the current working directory. Is there a way to specify that this relative url is from the location of the script instead?

Kod tabanımızdaki birkaç şablon dosyasını geçerli dizine kopyalayacak iş için basit bir yardımcı betik oluşturuyorum. Ancak şablonların depolandığı dizine mutlak yolum yok. Betikten göreceli bir yolum var ancak betiği çağırdığımda bunu geçerli çalışma dizinine göre bir yol olarak değerlendiriyor. Bunun yerine bu göreceli URL'nin betiğin konumundan olduğunu belirtmenin bir yolu var mı?

Python have already evolve to the ```__future__``` long time ago. So how about using the amazing ```pathlib``` coming with Python 3.4 to accomplish the task instead of struggling with ```os```, ```os.path```, ```glob ```, ```shutil```, etc. So we have 3 paths here (possibly duplicated): * ```mod_path```: which is the path of the simple helper script * ```src_path```: which contains a couple of template files waiting to be copied. * ```cwd```: current directory, the destination of those template files. and the problem is: we don't have the full path of ```src_path```, only know it's relative path to the ```mod_path```. Now let's solve this with the the amazing ```pathlib```: ```# Hope you don't be imprisoned by legacy Python code :) from pathlib import Path # `cwd`: current directory is straightforward cwd = Path.cwd() # `mod_path`: According to the accepted answer and combine with future power # if we are in the `helper_script.py` mod_path = Path(__file__).parent # OR if we are `import helper_script` mod_path = Path(helper_script.__file__).parent # `src_path`: with the future power, it's just so straightforward relative_path_1 = 'same/parent/with/helper/script/' relative_path_2 = '../../or/any/level/up/' src_path_1 = (mod_path / relative_path_1).resolve() src_path_2 = (mod_path / relative_path_2).resolve() ``` In the future, it's just that simple. Moreover, we can select and check and copy/move those template files with ```pathlib```: ```if src_path != cwd: # When we have different types of files in the `src_path` for template_path in src_path.glob('*.ini'): fname = template_path.name target = cwd / fname if not target.exists(): # This is the COPY action with target.open(mode='wb') as fd: fd.write(template_path.read_bytes()) # If we want MOVE action, we could use: # template_path.replace(target) ```

Python çok uzun zaman önce ```__future__```'a evrimleşti. O halde ```os```, ```os.path```, ```glob ```, ```shutil``` vb. ile uğraşmak yerine görevi yerine getirmek için Python 3.4 ile gelen muhteşem ```pathlib```'yi kullanmaya ne dersiniz? Yani burada 3 yolumuz var (muhtemelen kopyalanmış): * ```mod_path```: basit yardımcı betiğin yolu * ```src_path```: kopyalanmayı bekleyen birkaç şablon dosyası içerir. * ```cwd```: geçerli dizin, bu şablon dosyalarının hedefi. ve sorun şu: ```src_path```'in tam yoluna sahip değiliz, yalnızca ```mod_path```'e göreli yolunu biliyoruz. Şimdi bunu muhteşem ```pathlib``` ile çözelim: ```# Umarım eski Python koduyla hapsedilmezsiniz :) from pathlib import Path # `cwd`: geçerli dizin basittir cwd = Path.cwd() # `mod_path`: Kabul edilen cevaba göre ve gelecekteki güçle birleştirin # `helper_script.py` içindeysek mod_path = Path(__file__).parent # VEYA `import helper_script` isek mod_path = Path(helper_script.__file__).parent # `src_path`: gelecekteki güçle, çok basit relative_path_1 = 'same/parent/with/helper/script/' relative_path_2 = '../../or/any/level/up/' src_path_1 = (mod_path / relative_path_1).resolve() src_path_2 = (mod_path / relative_path_2).resolve() ``` Gelecekte bu kadar basit olacak. Dahası, bu şablon dosyalarını ```pathlib``` ile seçebilir, kontrol edebilir ve kopyalayabilir/taşınabiliriz: ```if src_path != cwd: # `src_path` içinde farklı türde dosyalarımız olduğunda for template_path in src_path.glob('*.ini'): fname = template_path.name target = cwd / fname if not target.exists(): # Bu KOPYALAMA eylemidir with target.open(mode='wb') as fd: fd.write(template_path.read_bytes()) # TAŞIMA eylemi istiyorsak şunları kullanabiliriz: # template_path.replace(target) ```

How to send HTML-formatted email in C#?

C# ile HTML biçimli e-posta nasıl gönderilir?

Setting isBodyHtml to true allows you to use HTML tags in the message body: ``` msg = new MailMessage("[email protected]", "[email protected]", "Message from PSSP System", "This email sent by the PSSP system<br />" + "<b>this is bold text!</b>"); msg.IsBodyHtml = true; ```

isBodyHtml'yi true olarak ayarlamak, ileti gövdesinde HTML etiketleri kullanmanıza olanak tanır: ``` msg = new MailMessage("[email protected]", "[email protected]", "PSSP Sisteminden Mesaj", "Bu e-posta PSSP sistemi tarafından gönderildi<br />" + "<b>bu kalın metindir!</b>"); msg.IsBodyHtml = true; ```

I want to sum a list of Integers. It works as follows, but the syntax does not feel right. Could the code be optimized? ```Map integers; integers.values().stream().mapToInt(i -> i).sum(); ```

Bir Tamsayı listesini toplamak istiyorum. Aşağıdaki gibi çalışıyor, ancak söz dizimi doğru gelmiyor. Kod optimize edilebilir mi? ```Map integers; integers.values().stream().mapToInt(i -> i).sum(); ```

This will work, but the `i -> i` is doing some automatic unboxing which is why it "feels" strange. `mapToInt` converts the stream to an `IntStream` "of primitive int-valued elements". Either of the following will work and better explain what the compiler is doing under the hood with your original syntax: ``` integers.values().stream().mapToInt(i -> i.intValue()).sum(); integers.values().stream().mapToInt(Integer::intValue).sum(); ``` The other simple option is `BigDecimal sum = numbers.stream().reduce(BigDecimal.ZERO, BigDecimal::add);`.

Bu işe yarayacaktır, ancak `i -> i` otomatik olarak kutudan çıkarma yapmaktadır ve bu nedenle "garip" hissettirir. `mapToInt`, akışı "ilkel int değerli öğelerden oluşan" bir `IntStream`'e dönüştürür. Aşağıdakilerden herhangi biri işe yarayacak ve derleyicinin orijinal söz diziminizle arka planda ne yaptığını daha iyi açıklayacaktır: ``` integers.values().stream().mapToInt(i -> i.intValue()).sum(); integers.values().stream().mapToInt(Integer::intValue).sum(); ``` Diğer basit seçenek ise `BigDecimal sum = numbers.stream().reduce(BigDecimal.ZERO, BigDecimal::add);`'dir.

I am beginner of LaTeX. From many examples I found, I notice that it's very common to use command ```\leavevmode```. I can't find any information about this command. Could anyone tell me what's the function of it and how to use it?

LaTeX'te yeniyim. Bulduğum birçok örnekte ```\leavevmode``` komutunun kullanıldığını fark ettim. Bu komut hakkında herhangi bir bilgi bulamıyorum. Birisi bana bunun işlevini ve nasıl kullanılacağını söyleyebilir mi?

The ```\leavevmode``` is defined by LaTeX and plainTeX and ensures that the vertical mode is ended and horizontal mode is entered. In vertical mode, TeX stacks horizontal boxes vertically, whereas in horizontal mode, they are taken as part of the text line. For example ```\mbox{..}``` is defined as ```\leavevmode\hbox{..}``` to ensure that horizontal mode is entered if it is used at the beginning of a paragraph. If you only use ```\hbox{ }``` it is stacked above the following paragraph instead. Compare: ```Text\par\hbox{Hello} World ``` Result: ``` Text Hello World ``` with: ```Text\par\mbox{Hello} World ``` Result: ``` Text Hello World ``` You see that in the first case the ```\hbox``` is stacked with the two paragraphs vertically (but without paragraph indention) because it is processed in vertical mode. In the second case horizontal mode is entered first and so ```Hello``` is processed as part of the second paragraph. Use ```\leavevmode``` for all macros which could be used at the begin of the paragraph and add horizontal boxes by themselves (e.g. in form of text). For further reading about ```\leavevmode``` please see "The TeXBook" by Donald E. Knuth, Appendix A, section 13.1, page 313 as well Appendix B, page 356.

```\leavevmode``` LaTeX ve plainTeX tarafından tanımlanmıştır ve dikey modun sonlandırıldığını ve yatay moda girildiğini garanti eder. Dikey modda, TeX yatay kutuları dikey olarak yığarken, yatay modda bunlar metin satırının bir parçası olarak alınır. Örneğin ```\mbox{..}``` bir paragrafın başında kullanıldığında yatay moda girilmesini sağlamak için ```\leavevmode\hbox{..}``` olarak tanımlanır. Sadece ```\hbox{ }``` kullanırsanız bunun yerine sonraki paragrafın üzerine yığılır. Karşılaştırın: ```Text\par\hbox{Merhaba} Dünya ``` Sonuç: ``` Metin Merhaba Dünya ``` ile: ```Text\par\mbox{Merhaba} Dünya ``` Sonuç: ``` Metin Merhaba Dünya ``` İlk durumda ```\hbox```'un dikey modda işlendiğinden iki paragrafla dikey olarak (ancak paragraf girintisi olmadan) yığıldığını görürsünüz. İkinci durumda önce yatay moda girilir ve böylece ```Merhaba``` ikinci paragrafın bir parçası olarak işlenir. Paragrafın başında kullanılabilecek ve yatay kutuları kendi başlarına ekleyen (örneğin metin biçiminde) tüm makrolar için ```\leavevmode``` kullanın. ```\leavevmode``` hakkında daha fazla bilgi için lütfen Donald E. Knuth'un "The TeXBook" kitabının Ek A, bölüm 13.1, sayfa 313 ve Ek B, sayfa 356'sına bakın.

In Python specifically, how do variables get shared between threads? Although I have used ```threading.Thread``` before I never really understood or saw examples of how variables got shared. Are they shared between the main thread and the children or only among the children? When would I need to use thread local storage to avoid this sharing? I have seen many warnings about synchronizing access to shared data among threads by using locks but I have yet to see a really good example of the problem. Thanks in advance!

Özellikle Python'da değişkenler iş parçacıkları arasında nasıl paylaşılır? ```threading.Thread```'i daha önce kullanmış olsam da değişkenlerin nasıl paylaşıldığına dair örnekleri hiç anlamadım veya görmedim. Ana iş parçacığı ve alt iş parçacıkları arasında mı yoksa yalnızca alt iş parçacıkları arasında mı paylaşılırlar? Bu paylaşımı önlemek için ne zaman iş parçacığı yerel depolamasını kullanmam gerekir? İş parçacıkları arasında paylaşılan verilere erişimi kilitler kullanarak senkronize etme konusunda birçok uyarı gördüm ancak sorunun gerçekten iyi bir örneğini henüz görmedim. Şimdiden teşekkürler!

In Python, everything is shared, except for function-local variables (because each function call gets its own set of locals, and threads are always separate function calls.) And even then, only the variables themselves (the names that refer to objects) are local to the function; objects themselves are always global, and anything can refer to them. The `Thread` object for a particular thread is not a special object in this regard. If you store the `Thread` object somewhere all threads can access (like a global variable) then all threads can access that one Thread object. If you want to atomically modify anything that another thread has access to, you have to protect it with a lock. And all threads must of course share this very same lock, or it wouldn't be very effective. If you want actual thread-local storage, that's where `threading.local` comes in. Attributes of `threading.local` are not shared between threads; each thread sees only the attributes it itself placed in there. If you're curious about its implementation, the source is in _threading_local.py in the standard library.

Python'da, fonksiyon-yerel değişkenler hariç her şey paylaşılır (çünkü her fonksiyon çağrısı kendi yerel kümesini alır ve iş parçacıkları her zaman ayrı fonksiyon çağrılarıdır). Ve o zaman bile, yalnızca değişkenlerin kendileri (nesnelere atıfta bulunan adlar) fonksiyona yereldir; nesnelerin kendileri her zaman küreseldir ve her şey onlara atıfta bulunabilir. Belirli bir iş parçacığı için `Thread` nesnesi bu açıdan özel bir nesne değildir. `Thread` nesnesini tüm iş parçacıklarının erişebileceği bir yerde (küresel bir değişken gibi) saklarsanız, tüm iş parçacıkları o Thread nesnesine erişebilir. Başka bir iş parçacığının erişebileceği bir şeyi atomik olarak değiştirmek istiyorsanız, onu bir kilit ile korumalısınız. Ve elbette tüm iş parçacıkları aynı kilidi paylaşmalıdır, aksi takdirde çok etkili olmaz. Gerçek iş parçacığı-yerel depolama istiyorsanız, `threading.local` devreye girer. `threading.local` öznitelikleri iş parçacıkları arasında paylaşılmaz; her iş parçacığı yalnızca oraya yerleştirdiği öznitelikleri görür. Uygulaması hakkında merak ediyorsanız, kaynak standart kitaplıktaki _threading_local.py'dedir.

I grew up in a country where we were not allowed to leave/travel to an other country even when we were able to do so – we had the resources and dual nationality. After two decades I still can't figure out why dictators, like Kim Jong-un for example, ban people from leaving their home countries? Could it be that a dictator is usually interested in looting the country he rules, and having a smaller population means more natural resources for him and fewer protesters?

Başka bir ülkeye gitmemize/seyahat etmemize izin verilmeyen bir ülkede büyüdüm, bunu yapabilecekken bile - kaynaklarımız ve çifte vatandaşlığımız vardı. Yirmi yıl sonra bile hâlâ Kim Jong-un gibi diktatörlerin insanları kendi ülkelerinden ayrılmaktan neden men ettiğini anlayamıyorum? Bir diktatörün genellikle yönettiği ülkeyi yağmalamakla ilgilendiği ve daha az nüfusa sahip olmanın kendisi için daha fazla doğal kaynak ve daha az protestocu anlamına gelebileceği olabilir mi?

People are resources, dictators (and oppressive regimes in general) don't want them to defect to other countries because they want them working for their regime. Some of them are going to be people that the regime has put their resources into, like scientists and doctors, but even laborers are valuable for actually gathering and assembling the resources the regime needs. Additionally, the regime especially does not want people with access to sensitive information to defect to their enemies. That isn't just spies and soldiers, there are plenty of "regular" government positions that require access to something the regime would not want falling into enemy hands, like economic data that could be used for propaganda. Obviously this is true of any country, and even in democracies with strong human rights records, people with access to classified information are usually required to submit to strict scrutiny of their international travel. Given that they aren't concerned with human rights, dictatorships can take the easier option of restricting travel to any citizens. However, defection is really a piece of a bigger issue - oppressive regimes maintain their rule in part by controlling information. Here's an interesting article that talks about how dictatorships keep power. Jerrold Post, director of the political psychology program at George Washington University, is referenced: Post said that in both Iraq and North Korea, dictators tightly controlled the flow of information. That control was upended in the past two years during the "Arab spring" revolts that swept away despots in Tunisia, Egypt, Libya and some of the Gulf states, revolts that were encouraged in large part by information spread by cell phones and social media. North Korea is probably the most extreme example of information control (according to Reporters without Borders, they are dead last in Press Freedom in the world), but this can be seen in other oppressive regimes - for example, China attempts to limit access to "wrong" information via its Great Firewall. This is thrown out the window if citizens go somewhere with free media and realize they are being lied to. Traveling can be the cause of their dissension, rather than a symptom. Known dissidents may also be restricted from traveling so that they can not coordinate with foreign countries or anti-dictatorship organizations, and to prevent them from smuggling contraband or evidence of the regime's misinformation back into the country. Regimes can control the information originating in their country, but once someone is outside their borders the regime cannot control who they speak with.

İnsanlar kaynaklardır, diktatörler (ve genel olarak baskıcı rejimler) onların diğer ülkelere kaçmasını istemezler çünkü onları kendi rejimleri için çalıştırmak isterler. Bazıları rejimin kaynaklarını yatırdığı bilim insanları ve doktorlar gibi insanlar olacaktır, ancak işçiler bile rejimin ihtiyaç duyduğu kaynakları toplamak ve bir araya getirmek için değerlidir. Ayrıca rejim, özellikle hassas bilgilere erişimi olan kişilerin düşmanlarına kaçmasını istemez. Bunlar sadece casuslar ve askerler değildir, rejimin düşman eline geçmesini istemeyeceği bir şeye erişim gerektiren birçok "normal" hükümet pozisyonu vardır, örneğin propaganda için kullanılabilecek ekonomik veriler gibi. Açıkçası bu her ülke için geçerlidir ve insan hakları sicili güçlü demokrasilerde bile, gizli bilgilere erişimi olan kişilerin genellikle uluslararası seyahatlerinin sıkı incelemeye tabi tutulması gerekir. İnsan haklarıyla ilgilenmedikleri göz önüne alındığında, diktatörlükler herhangi bir vatandaşın seyahatini kısıtlama gibi daha kolay bir seçenek alabilirler. Ancak kaçış gerçekten daha büyük bir sorunun bir parçasıdır - baskıcı rejimler, bilgiyi kontrol ederek kısmen yönetimlerini sürdürürler. İşte diktatörlüklerin gücü nasıl koruduğu hakkında konuşan ilginç bir makale. George Washington Üniversitesi'ndeki siyasi psikoloji programının direktörü Jerrold Post'a atıfta bulunuluyor: Post, hem Irak'ta hem de Kuzey Kore'de diktatörlerin bilgi akışını sıkı bir şekilde kontrol ettiğini söyledi. Bu kontrol, Tunus, Mısır, Libya ve bazı Körfez ülkelerindeki despotları süpüren "Arap baharı" isyanları sırasında son iki yılda alt üst oldu; bu isyanlar büyük ölçüde cep telefonları ve sosyal medya tarafından yayılan bilgilerle teşvik edildi. Kuzey Kore muhtemelen bilgi kontrolünün en uç örneğidir (Sınır Tanımayan Gazeteciler'e göre, dünya çapında Basın Özgürlüğü'nde sonuncu sırada yer almaktadır), ancak bu diğer baskıcı rejimlerde de görülebilir - örneğin Çin, Büyük Güvenlik Duvarı aracılığıyla "yanlış" bilgilere erişimi sınırlamaya çalışmaktadır. Vatandaşlar özgür medyanın olduğu bir yere giderlerse ve kendilerine yalan söylendiğini fark ederlerse bu pencereden dışarı atılır. Seyahat, bir semptomdan ziyade onların muhalefetlerinin nedeni olabilir. Bilinen muhaliflerin de yabancı ülkelerle veya diktatörlük karşıtı örgütlerle koordinasyon kuramamaları ve ülkeye yasaklı madde veya rejimin yanlış bilgisinin kanıtlarını sokmalarını önlemek için seyahat etmeleri kısıtlanabilir. Rejimler ülkelerinde ortaya çıkan bilgileri kontrol edebilirler, ancak birisi sınırlarının dışına çıktığında rejim onun kiminle konuştuğunu kontrol edemez.

Why can't we kill ourselves by holding our breath?

Neden nefesimizi tutarak kendimizi öldüremiyoruz?

## Short answer Healthy people cannot hold their breaths until unconsciousness sets in, let alone commit suicide. ## Background According to Parkes (2005), a normal person cannot even hold their breath to unconsciousness, let alone death. Parkes says: Breath‐holding is a voluntary act, but normal subjects appear unable to breath‐hold to unconsciousness. A powerful involuntary mechanism normally overrides voluntary breath‐holding and causes the breath that defines the breakpoint. Parkes explains that voluntary breath‐holding does not stop the central respiratory rhythm. Instead, breath holding merely suppresses its expression by voluntarily holding the chest at a certain volume. At the time of writing, no simple explanation for the break point existed. It is known to be caused by partial pressures of blood gases activating the carotid arterial chemoreceptors. They are peripheral sensory neurons that detect changes in chemical concentrations, including low oxygen (hypoxia) and high carbon dioxide (hypercapnia). Both hypoxia and hypercapnia are signs of breath holding and both are detected by the chemoreceptors. These receptors send nerve signals to the vasomotor center of the medulla which eventually overrides the conscious breath holding. The breaking point can be postponed by large lung inflations, hyperoxia and hypocapnia, and it is shortened by increased metabolic rates. Reference - Parkes, Exp Physiol (2006); 91(1): 1-15

## Kısa cevap Sağlıklı insanlar bilinç kaybı gerçekleşene kadar nefeslerini tutamazlar, intihar etmeyi bir kenara bırakın. ## Arka plan Parkes'e (2005) göre, normal bir kişi ölüm bir yana, bilinç kaybına kadar nefesini bile tutamaz. Parkes şöyle diyor: Nefes tutma isteğe bağlı bir eylemdir, ancak normal denekler bilinç kaybına kadar nefes tutamazlar. Güçlü bir istemsiz mekanizma normalde isteğe bağlı nefes tutmayı geçersiz kılar ve sınır noktasını tanımlayan nefese neden olur. Parkes, isteğe bağlı nefes tutmanın merkezi solunum ritmini durdurmadığını açıklar. Bunun yerine, nefes tutma yalnızca göğsü belirli bir hacimde tutarak ifadesini bastırır. Yazım sırasında, kırılma noktası için basit bir açıklama yoktu. Karotid arteriyel kemoreseptörlerini aktive eden kan gazlarının kısmi basınçlarından kaynaklandığı bilinmektedir. Bunlar, düşük oksijen (hipoksi) ve yüksek karbondioksit (hiperkapni) dahil olmak üzere kimyasal konsantrasyonlardaki değişiklikleri algılayan periferik duyu nöronlarıdır. Hem hipoksi hem de hiperkapni nefes tutmanın belirtileridir ve her ikisi de kemoreseptörler tarafından tespit edilir. Bu reseptörler, sonunda bilinçli nefes tutmayı geçersiz kılan medulla'nın vazomotor merkezine sinir sinyalleri gönderir. Kırılma noktası, büyük akciğer şişmeleri, hiperoksi ve hipokapni ile ertelenebilir ve artan metabolik hızlarla kısalır. Referans - Parkes, Exp Physiol (2006); 91(1): 1-15

Sometimes while driving in the traffic, I come across a car or two which would be dripping water-like drops from its exhaust steadily in 4-5 second intervals. I tried to ask a couple of people at the local workshops; they say, and I quote, &quot;The car is giving an amazing mileage&quot;. And I am like, what does that water dripping mean even then? Why does the water drip? What is the source of it? And what does it signify?

Bazen trafikte seyir halindeyken, egzozundan 4-5 saniye aralıklarla su damlası gibi damlalar damlatan bir veya iki arabayla karşılaşıyorum. Yerel atölyelerde birkaç kişiye sormaya çalıştım; "Araba inanılmaz bir kilometre yapıyor" diyorlar ve alıntı yapıyorum. Ve ben de, o zaman bile o su damlaması ne anlama geliyor? Neden su damlıyor? Kaynağı nedir? Ve neyi ifade ediyor?

It signifies that the car is running absolutely correct. Here is the reason why: A gasoline (petrol) molecule is made up as such: C8H18 (or 8 Carbon atoms and 18 Hydrogen atoms) Energy is obtained from the combustion of it by the conversion of a hydrocarbon to carbon dioxide and water. The combustion of octane follows this reaction: 2 C8H18 + 25 O2 → 16 CO2 + 18 H2O Or better said, you have two of the hydrocarbon molecules along with 25 oxygen molecules, they swirl together into a mix, the spark plug ignites them, boom, and out the tail pipe comes 16 carbon dioxide molecules and 18 water molecules ... at least in a perfect world. Some cars don't put out exactly that ratio. There may be a little bit of carbon monoxide (CO), unburnt hydrocarbons (C8H18), and/or nitrogen oxide (NO2) coming out of the engine exhaust port along with the CO2 and H2O. In this case, the catalytic convertor's job is to help clean these up so you can get closer to the perfect ratio described above. As described, the water coming out of the tail pipe is a natural occurrence of the combustion process. You will usually see it coming out of the tail pipe when the engine and exhaust system of the vehicle is not completely warmed up. When it does become completely warmed up, you won't see it any more, because it comes out as steam (well, you'll see it in the winter time if it's cold enough, but you get the idea).

Arabanın kesinlikle doğru çalıştığını gösterir. İşte nedeni: Bir benzin (petrol) molekülü şu şekilde oluşur: C8H18 (veya 8 Karbon atomu ve 18 Hidrojen atomu) Enerji, bir hidrokarbonun karbondioksite ve suya dönüştürülmesiyle yanmasından elde edilir. Oktanın yanması şu reaksiyonu izler: 2 C8H18 + 25 O2 → 16 CO2 + 18 H2O Veya daha iyi ifade etmek gerekirse, 25 oksijen molekülüyle birlikte iki hidrokarbon molekülünüz var, bunlar bir karışım halinde bir araya gelir, buji onları tutuşturur, patlar ve kuyruk borusundan 16 karbondioksit molekülü ve 18 su molekülü çıkar... en azından mükemmel bir dünyada. Bazı arabalar tam olarak bu oranı vermez. Motor egzoz portundan CO2 ve H2O ile birlikte biraz karbon monoksit (CO), yanmamış hidrokarbonlar (C8H18) ve/veya azot oksit (NO2) çıkabilir. Bu durumda, katalitik konvertörün görevi, yukarıda açıklanan mükemmel orana daha da yaklaşabilmeniz için bunları temizlemeye yardımcı olmaktır. Açıklandığı gibi, kuyruk borusundan çıkan su, yanma sürecinin doğal bir sonucudur. Genellikle motor ve aracın egzoz sistemi tamamen ısınmadığında kuyruk borusundan çıktığını görürsünüz. Tamamen ısındığında, artık görmezsiniz çünkü buhar olarak çıkar (yani, yeterince soğuksa kışın görürsünüz, ancak fikri anladınız).

Why can't MX records point to an IP address?

MX kayıtları neden bir IP adresine işaret edemez?

The whole idea behind the mail exchange (MX) record is to specify a host or hosts which can accept mail for a domain. As specified in RFC 1035, the MX record contains a domain name. It must therefore point to a host which itself can be resolved in the DNS. An IP address could not be used as it would be interpreted as an unqualified domain name, which cannot be resolved. The reasons for this in the 1980s, when the specs were originally written, are almost the same as the reasons for it today: A host may be connected to multiple networks and use multiple protocols. Back in the 80s, it was not uncommon to have mail gateways which connected both to the (relatively new) Internet which used TCP/IP and to other legacy networks, which often used other protocols. Specifying MX in this way allowed for DNS records which could identify how to reach such a host on a network other than the Internet, such as Chaosnet. In practice, though, this almost never happened; virtually everyone re-engineered their networks to become part of the Internet instead. Today, the situation is that a host may be reached by multiple protocols (IPv4 and IPv6) and by multiple IP addresses in each protocol. A single MX record can't possibly list more than one address, so the only option is to point to a host, where all of that host's addresses can then be looked up. (As a performance optimization, the DNS server will send along the address records for the host in the response additional section if it has authoritative records for them, saving a round trip.) There is also the situation that arises when your mail exchangers are provided by a third party (e.g. Google Apps or Office 365). You point your MX records to their hostnames, but it may occur that the service provider needs to change the mail servers' IP addresses. Since you have pointed to a host, the service provider can do this transparently and you don't have to make any changes to your records.

E-posta değişim (MX) kaydının ardındaki fikir, bir alan adı için e-posta kabul edebilecek bir veya daha fazla ana bilgisayarı belirtmektir. RFC 1035'te belirtildiği gibi, MX kaydı bir alan adı içerir. Bu nedenle, DNS'te çözümlenebilen bir ana bilgisayarı işaret etmelidir. Bir IP adresi, çözümlenemeyen niteliksiz bir alan adı olarak yorumlanacağı için kullanılamaz. Özelliklerin ilk yazıldığı 1980'lerde bunun nedenleri, günümüzdeki nedenlerle hemen hemen aynıdır: Bir ana bilgisayar birden fazla ağa bağlanabilir ve birden fazla protokol kullanabilir. 80'lerde, hem TCP/IP kullanan (nispeten yeni) İnternet'e hem de genellikle diğer protokolleri kullanan diğer eski ağlara bağlanan posta ağ geçitlerine sahip olmak alışılmadık bir şey değildi. MX'i bu şekilde belirtmek, Chaosnet gibi İnternet dışındaki bir ağda böyle bir ana bilgisayara nasıl ulaşılacağını tanımlayabilen DNS kayıtlarına izin verdi. Ancak pratikte bu neredeyse hiç olmadı; hemen hemen herkes ağlarını yeniden tasarlayarak bunun yerine İnternet'in bir parçası haline getirdi. Günümüzde durum, bir ana bilgisayara birden fazla protokol (IPv4 ve IPv6) ve her protokolde birden fazla IP adresi üzerinden ulaşılabilmesidir. Tek bir MX kaydı birden fazla adresi listeleyemez, bu nedenle tek seçenek, o ana bilgisayarın tüm adreslerinin aranabileceği bir ana bilgisayarı işaret etmektir. (Bir performans optimizasyonu olarak, DNS sunucusu, yetkili kayıtları varsa, yanıt ek bölümünde ana bilgisayarın adres kayıtlarını gönderecek ve böylece gidiş-dönüş yolculuğundan tasarruf edecektir.) Ayrıca, posta sunucularınızın üçüncü bir tarafça (ör. Google Apps veya Office 365) sağlandığı durumlarda ortaya çıkan bir durum vardır. MX kayıtlarınızı onların ana bilgisayar adlarına yönlendirirsiniz, ancak servis sağlayıcının posta sunucularının IP adreslerini değiştirmesi gerekebilir. Bir ana bilgisayarı işaret ettiğiniz için, servis sağlayıcı bunu şeffaf bir şekilde yapabilir ve kayıtlarınızda herhangi bir değişiklik yapmanıza gerek kalmaz.

Why is ```SELECT *``` bad practice? Wouldn't it mean less code to change if you added a new column you wanted? I understand that ```SELECT COUNT(*)``` is a performance problem on some DBs, but what if you really wanted every column?

```SELECT *``` neden kötü bir uygulamadır? İstediğiniz yeni bir sütun eklediğinizde değiştirilecek daha az kod anlamına gelmez mi? ```SELECT COUNT(*)```'in bazı veritabanlarında bir performans sorunu olduğunu anlıyorum, ancak gerçekten her sütuna ihtiyacınız varsa ne olur?

The asterisk character, "*", in the SELECT statement is shorthand for all the columns in the table(s) involved in the query. Performance The ```*``` shorthand can be slower because: * Not all the fields are indexed, forcing a full table scan - less efficient * What you save to send ```SELECT *``` over the wire risks a full table scan * Returning more data than is needed * Returning trailing columns using variable length data type can result in search overhead Maintenance When using ```SELECT *```: * Someone unfamiliar with the codebase would be forced to consult documentation to know what columns are being returned before being able to make competent changes. Making code more readable, minimizing the ambiguity and work necessary for people unfamiliar with the code saves more time and effort in the long run. * If code depends on column order, ```SELECT *``` will hide an error waiting to happen if a table had its column order changed. * Even if you need every column at the time the query is written, that might not be the case in the future * the usage complicates profiling Design ```SELECT *``` is an anti-pattern: * The purpose of the query is less obvious; the columns used by the application is opaque * It breaks the modularity rule about using strict typing whenever possible. Explicit is almost universally better. When Should "SELECT *" Be Used? It's acceptable to use ```SELECT *``` when there's the explicit need for every column in the table(s) involved, as opposed to every column that existed when the query was written. The database will internally expand the * into the complete list of columns - there's no performance difference. Otherwise, explicitly list every column that is to be used in the query - preferably while using a table alias.

SELECT ifadesindeki yıldız karakteri "*" sorguda yer alan tablo(lar)daki tüm sütunlar için kısayoldur. Performans ```*``` kısayolu daha yavaş olabilir çünkü: * Tüm alanlar indekslenmediğinden tam tablo taraması zorlanır - daha az verimli * ```SELECT *```'i kablo üzerinden göndermek için kaydettiğiniz şey tam tablo taraması riskini taşır * Gerekenden daha fazla veri döndürür * Değişken uzunluklu veri türünü kullanarak son sütunları döndürmek arama yüküne neden olabilir Bakım ```SELECT *``` kullanırken: * Kod tabanına aşina olmayan biri, yetkin değişiklikler yapabilmek için hangi sütunların döndürüldüğünü bilmek için belgelere danışmak zorunda kalır. Kodu daha okunabilir hale getirmek, belirsizliği en aza indirmek ve koda aşina olmayan kişiler için gerekli olan işi yapmak uzun vadede daha fazla zaman ve çaba tasarrufu sağlar. * Kod sütun sırasına bağlıysa, ```SELECT *``` bir tablonun sütun sırası değiştirildiğinde gerçekleşmeyi bekleyen bir hatayı gizler. * Sorgunun yazıldığı anda her sütuna ihtiyacınız olsa bile, gelecekte durum böyle olmayabilir * kullanım profili oluşturmayı karmaşıklaştırır Tasarım ```SELECT *``` bir anti-kalıptır: * Sorgunun amacı daha az açıktır; uygulama tarafından kullanılan sütunlar belirsizdir * Mümkün olduğunda kesin yazım kullanma modülerlik kuralını bozar. Açık yazım neredeyse her zaman daha iyidir. "SELECT *" Ne Zaman Kullanılmalıdır? Sorgunun yazıldığı sırada var olan her sütun yerine, ilgili tablo(lar)daki her sütuna açık bir ihtiyaç olduğunda ```SELECT *``` kullanmak kabul edilebilir. Veritabanı, *'i dahili olarak tam sütun listesine genişletir - performans farkı yoktur. Aksi takdirde, sorguda kullanılacak her sütunu açıkça listeleyin - tercihen bir tablo takma adı kullanırken.

I did my training around the Seattle area, and was told that landing at SeaTac Airport (the region's major International/Commercial airport), while not strictly forbidden, was definitely frowned upon because it can slow down and interfere with the big planes on schedules. To discourage GA aircraft from using the big airport, they have a variety of landing fees, ramp fees, and prior-approval requirements. But later, I moved near MCI, and was told that landing at the big airport was no big deal. That they're actually happy to have little planes there. If you fly small GA planes, do you land at the major airports in your area? What advanced preparations can you make to minimize your impact on the "big boys", and remain a good airspace citizen?

Eğitimim Seattle bölgesindeydi ve SeaTac Havaalanı'na (bölgenin büyük Uluslararası/Ticari havaalanı) inişin kesinlikle yasaklanmasa da, kesinlikle hoş karşılanmadığı söylendi çünkü büyük uçakların programlarını yavaşlatıp aksatabiliyor. GA uçaklarının büyük havaalanını kullanmasını engellemek için çeşitli iniş ücretleri, rampa ücretleri ve önceden onay alma gereklilikleri var. Ama daha sonra MCI'ın yakınına taşındım ve büyük havaalanına inişin sorun olmadığı söylendi. Küçük uçakların orada olmasından aslında memnunlarmış. Küçük GA uçakları uçuruyorsanız, bölgenizdeki büyük havaalanlarına iniş yapıyor musunuz? "Büyük çocuklara" etkinizi en aza indirmek ve iyi bir hava sahası vatandaşı olarak kalmak için hangi gelişmiş hazırlıkları yapabilirsiniz?

Can you? Absolutely, and air traffic control will treat you (almost) like any other airplane. You are supposedly handled on a first-come-first-serve basis (reality is slightly different with different aircraft speeds, etc.). Do the airlines like it if you slow them down? No, but it's part of the system and the way that it works. Very often, there are multiple runways at bigger airports, and sometimes there are even shorter runways that are dedicated for airplanes that don't need to land on the same one as the "big boys". Even if not, they will work you in. Now, that being said, very often there is a better option. As you said, there are usually high fees at the big airports, so landing at a smaller satellite airport can often save you money and save you time because you won't have to taxi as far or sit and wait in line to get out. An extra 15 minutes by car can be better than an extra 30 minutes while taxiing. As far as being prepared, it isn't really much different than smaller airports other than the fact that ATC is much busier. They don't have the time/tolerance to keep repeating instructions to you, and expect you to be "on your game". When they rattle off taxi instructions like "Cessna N1234, taxi to the ramp via Alpha, Tango, Echo, and Xray. Hold short of runway 23." they expect a quick readback and for you to follow instructions exactly because they need to move on to the next guy. It will also help everyone out if you don't fly your final approach the way that most people are taught for an entire 10 mile final: very close to your actual landing speed. In fact, you are usually landing on a runway that is 4X+ the distance that you need and you can slow down fairly quickly (especially compared to a jet), so if you can fly an extra 20 (or 80) knots as long as possible, it will be greatly appreciated and keep traffic moving. Make sure that you leave yourself enough time to slow down at the end and above all else, ***be safe***.

Yapabilir misin? Kesinlikle ve hava trafik kontrolü sana (neredeyse) diğer uçaklar gibi davranacaktır. Normalde ilk gelen ilk hizmet alır şeklinde ele alınırsın (gerçekte farklı uçak hızları vb. ile biraz farklılık gösterir). Havayolları onları yavaşlatmanı sever mi? Hayır, ama bu sistemin bir parçası ve çalışma şeklidir. Genellikle daha büyük havalimanlarında birden fazla pist bulunur ve bazen "büyük çocuklarla" aynı piste inmesi gerekmeyen uçaklar için ayrılmış daha kısa pistler bile vardır. Olmasa bile seni dahil ederler. Şimdi, bunların söylenmesiyle birlikte, genellikle daha iyi bir seçenek vardır. Dediğin gibi, büyük havalimanlarında genellikle yüksek ücretler vardır, bu nedenle daha küçük bir uydu havalimanına inmek genellikle paradan ve zamandan tasarruf etmeni sağlayabilir çünkü o kadar uzağa taksi yapmak veya dışarı çıkmak için sırada beklemek zorunda kalmazsın. Arabayla fazladan 15 dakika taksi yaparak fazladan 30 dakika beklemekten daha iyi olabilir. Hazırlıklı olmak açısından, ATC'nin çok daha yoğun olması dışında daha küçük havalimanlarından pek bir farkı yoktur. Sana talimatları tekrar tekrar söyleyecek zamanları/hoşgörüleri yoktur ve "oyunda" olmanı beklerler. "Cessna N1234, Alpha, Tango, Echo ve Xray üzerinden rampaya taksi yap. 23 numaralı pistin kısa tarafında bekle." gibi taksi talimatlarını sıraladıklarında, hızlı bir geri bildirim beklerler ve talimatları tam olarak uygulamanı beklerler çünkü bir sonraki kişiye geçmeleri gerekir. Ayrıca, çoğu insana 10 mil boyunca öğretilen son yaklaşmanı gerçek iniş hızına çok yakın bir şekilde uçmazsan herkese yardımcı olacaktır. Aslında, genellikle ihtiyacın olan mesafenin 4 katından fazla bir piste iniyorsun ve oldukça hızlı bir şekilde yavaşlayabilirsin (özellikle bir jete kıyasla), bu nedenle mümkün olduğunca 20 (veya 80) knot daha fazla uçabilirsen, bu çok takdir edilecek ve trafiğin akmasını sağlayacaktır. Sonunda yavaşlamak için kendine yeterince zaman bıraktığından emin ol ve her şeyden önce ***güvenli ol***.

I need a way to compare multiple strings to a test string and return the string that closely resembles it: ```TEST STRING: THE BROWN FOX JUMPED OVER THE RED COW CHOICE A : THE RED COW JUMPED OVER THE GREEN CHICKEN CHOICE B : THE RED COW JUMPED OVER THE RED COW CHOICE C : THE RED FOX JUMPED OVER THE BROWN COW ``` (If I did this correctly) The closest string to the "TEST STRING" should be "CHOICE C". What is the easiest way to do this? I plan on implementing this into multiple languages including VB.net, Lua, and JavaScript. At this point, pseudo code is acceptable. If you can provide an example for a specific language, this is appreciated too!

Birden fazla dizeyi bir test dizesiyle karşılaştırmanın ve ona en çok benzeyen dizeyi döndürmenin bir yoluna ihtiyacım var: ```TEST DİZESİ: KAHVERENGİ TİLKİ KIRMIZI İNEĞİN ÜZERİNDEN ATLADI SEÇİM A : KIRMIZI İNEK YEŞİL TAVUĞUN ÜZERİNDEN ATLADI SEÇİM B : KIRMIZI İNEK KIRMIZI İNEĞİN ÜZERİNDEN ATLADI SEÇİM C : KAHVERENGİ TİLKİ KAHVERENGİ İNEĞİN ÜZERİNDEN ATLADI ``` (Bunu doğru yaptıysam) "TEST DİZESİ"ne en yakın dize "SEÇİM C" olmalıdır. Bunu yapmanın en kolay yolu nedir? Bunu VB.net, Lua ve JavaScript dahil olmak üzere birden fazla dile uygulamayı planlıyorum. Bu noktada, sözde kod kabul edilebilir. Belirli bir dil için bir örnek sağlayabiliyorsanız, bu da takdir edilir!

Fuzzy String Matching is the process of performing a human-like estimation of the similarity of two words or phrases. In many cases, it involves implementing the Levenshtein distance algorithm, which determines how many changes must be made to a string or phrase to turn it into another string or phrase. The following implementation in VBA involves a weighted comparison of the length of the two phrases, the number of changes between each phrase, and whether each word could be found in the target entry. ``` 'Calculate the Levenshtein Distance between two strings (the number of insertions, 'deletions, and substitutions needed to transform the first string into the second) Public Function LevenshteinDistance(ByRef S1 As String, ByVal S2 As String) As Long Dim L1 As Long, L2 As Long, D() As Long 'Length of input strings and distance matrix Dim i As Long, j As Long, cost As Long 'loop counters and cost of substitution for current letter Dim cI As Long, cD As Long, cS As Long 'cost of next Insertion, Deletion and Substitution L1 = Len(S1): L2 = Len(S2) ReDim D(0 To L1, 0 To L2) For i = 0 To L1: D(i, 0) = i: Next i For j = 0 To L2: D(0, j) = j: Next j For j = 1 To L2 For i = 1 To L1 cost = Abs(StrComp(Mid$(S1, i, 1), Mid$(S2, j, 1), vbTextCompare)) cI = D(i - 1, j) + 1 cD = D(i, j - 1) + 1 cS = D(i - 1, j - 1) + cost If cI <= cD Then 'Insertion or Substitution If cI <= cS Then D(i, j) = cI Else D(i, j) = cS Else 'Deletion or Substitution If cD <= cS Then D(i, j) = cD Else D(i, j) = cS End If Next i Next j LevenshteinDistance = D(L1, L2) End Function ``` We can creat two separate metrics for evaluating the similarity of two strings. One is "valuePhrase" and the other is "valueWords". valuePhrase is just the Levenshtein distance between the two phrases, and valueWords splits the string into individual words, based on delimiters such as spaces, dashes, and anything else you'd like, and compares each word to each other word, summing up the shortest Levenshtein distance connecting any two words. Essentially, it measures whether the information in one 'phrase' is really contained in another, just as a word-wise permutation. valueWords, valuePhrase, and Split function: ``` Public Function valuePhrase#(ByRef S1$, ByRef S2$) valuePhrase = LevenshteinDistance(S1, S2) End Function Public Function valueWords#(ByRef S1$, ByRef S2$) Dim wordsS1$(), wordsS2$() wordsS1 = SplitMultiDelims(S1, " _-") wordsS2 = SplitMultiDelims(S2, " _-") Dim word1%, word2%, thisD#, wordbest# Dim wordsTotal# For word1 = LBound(wordsS1) To UBound(wordsS1) wordbest = Len(S2) For word2 = LBound(wordsS2) To UBound(wordsS2) thisD = LevenshteinDistance(wordsS1(word1), wordsS2(word2)) If thisD < wordbest Then wordbest = thisD If thisD = 0 Then GoTo foundbest Next word2 foundbest: wordsTotal = wordsTotal + wordbest Next word1 valueWords = wordsTotal End Function '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ' SplitMultiDelims ' This function splits Text into an array of substrings, each substring ' delimited by any character in DelimChars. Only a single character ' may be a delimiter between two substrings, but DelimChars may ' contain any number of delimiter characters. It returns a single element ' array containing all of text if DelimChars is empty, or a 1 or greater ' element array if the Text is successfully split into substrings. ' If IgnoreConsecutiveDelimiters is true, empty array elements will not occur. ' If Limit greater than 0, the function will only split Text into 'Limit' ' array elements or less. The last element will contain the rest of Text. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' Function SplitMultiDelims(ByRef Text As String, ByRef DelimChars As String, _ Optional ByVal IgnoreConsecutiveDelimiters As Boolean = False, _ Optional ByVal Limit As Long = -1) As String() Dim ElemStart As Long, N As Long, M As Long, Elements As Long Dim lDelims As Long, lText As Long Dim Arr() As String lText = Len(Text) lDelims = Len(DelimChars) If lDelims = 0 Or lText = 0 Or Limit = 1 Then ReDim Arr(0 To 0) Arr(0) = Text SplitMultiDelims = Arr Exit Function End If ReDim Arr(0 To IIf(Limit = -1, lText - 1, Limit)) Elements = 0: ElemStart = 1 For N = 1 To lText If InStr(DelimChars, Mid(Text, N, 1)) Then Arr(Elements) = Mid(Text, ElemStart, N - ElemStart) If IgnoreConsecutiveDelimiters Then If Len(Arr(Elements)) > 0 Then Elements = Elements + 1 Else Elements = Elements + 1 End If ElemStart = N + 1 If Elements + 1 = Limit Then Exit For End If Next N 'Get the last token terminated by the end of the string into the array If ElemStart <= lText Then Arr(Elements) = Mid(Text, ElemStart) 'Since the end of string counts as the terminating delimiter, if the last character 'was also a delimiter, we treat the two as consecutive, and so ignore the last elemnent If IgnoreConsecutiveDelimiters Then If Len(Arr(Elements)) = 0 Then Elements = Elements - 1 ReDim Preserve Arr(0 To Elements) 'Chop off unused array elements SplitMultiDelims = Arr End Function ``` Using these two metrics, and a third which simply computes the distance between two strings, we have a series of variables which we can run an optimization algorithm to achieve the greatest number of matches. Fuzzy string matching is, itself, a fuzzy science, and so by creating linearly independent metrics for measuring string similarity, and having a known set of strings we wish to match to each other, we can find the parameters that, for our specific styles of strings, give the best fuzzy match results. To allow the optimization of fuzzy matching, we can weight each metric. The formula that defines the final score is a simply combination of the metrics and their weights: ``` value = Min(phraseWeight*phraseValue, wordsWeight*wordsValue)*minWeight + Max(phraseWeight*phraseValue, wordsWeight*wordsValue)*maxWeight + lengthWeight*lengthValue ``` For your specific context, you have to come up with a set of weights for any metrics you come up with to determine similarity. With the appropriate set of heuristics and weights, you'll have your comparison program quickly making the decisions that you would have made.

Belirsiz Dize Eşleştirme, iki sözcük veya cümlenin benzerliğini insan benzeri bir tahminle gerçekleştirme sürecidir. Birçok durumda, bir dizeyi veya cümleyi başka bir dizeye veya cümleye dönüştürmek için yapılması gereken değişiklik sayısını belirleyen Levenshtein uzaklık algoritmasını uygulamayı içerir. VBA'daki aşağıdaki uygulama, iki cümlenin uzunluğunun, her cümle arasındaki değişiklik sayısının ve her sözcüğün hedef girdide bulunup bulunmadığının ağırlıklı bir karşılaştırmasını içerir. ``` 'İki dize arasındaki Levenshtein Uzaklığını hesaplar (ilk dizeyi ikinci dizeye dönüştürmek için gereken ekleme, 'silme ve değiştirme sayısı) Public Function LevenshteinDistance(ByRef S1 As String, ByVal S2 As String) As Long Dim L1 As Long, L2 As Long, D() As Long 'Giriş dizelerinin uzunluğu ve uzaklık matrisi Dim i As Long, j As Long, cost As Long 'döngü sayaçları ve geçerli harf için değiştirme maliyeti Dim cI As Long, cD As Long, cS As Long 'sonraki Ekleme, Silme ve Değiştirme maliyeti L1 = Len(S1): L2 = Len(S2) ReDim D(0 To L1, 0 To L2) For i = 0 To L1: D(i, 0) = i: Next i For j = 0 To L2: D(0, j) = j: Next j For j = 1 To L2 For i = 1 To L1 cost = Abs(StrComp(Mid$(S1, i, 1), Mid$(S2, j, 1), vbTextCompare)) cI = D(i - 1, j) + 1 cD = D(i, j - 1) + 1 cS = D(i - 1, j - 1) + cost If cI <= cD Then 'Ekleme veya Değiştirme If cI <= cS Then D(i, j) = cI Else D(i, j) = cS Else 'Silme veya Değiştirme If cD <= cS Then D(i, j) = cD Else D(i, j) = cS End If Next i Next j LevenshteinDistance = D(L1, L2) End Function ``` İki dize arasındaki benzerliği değerlendirmek için iki ayrı ölçüt oluşturabiliriz. Biri "valuePhrase" diğeri ise "valueWords"tür. valuePhrase, iki cümle arasındaki Levenshtein uzaklığıdır ve valueWords, dizeyi boşluklar, tireler ve istediğiniz başka herhangi bir şey gibi sınırlayıcılara göre ayrı sözcüklere ayırır ve her sözcüğü diğer her sözcükle karşılaştırır ve iki sözcüğü birbirine bağlayan en kısa Levenshtein uzaklığını toplar. Esasen, bir "cümledeki" bilgilerin gerçekten başka bir cümlede, tıpkı sözcük bilge bir permütasyon gibi, yer alıp almadığını ölçer. valueWords, valuePhrase ve Split işlevi: ``` Public Function valuePhrase#(ByRef S1$, ByRef S2$) valuePhrase = LevenshteinDistance(S1, S2) End Function Public Function valueWords#(ByRef S1$, ByRef S2$) Dim wordsS1$(), wordsS2$() wordsS1 = SplitMultiDelims(S1, " _-") wordsS2 = SplitMultiDelims(S2, " _-") Dim word1%, word2%, thisD#, wordbest# Dim wordsTotal# For word1 = LBound(wordsS1) To UBound(wordsS1) wordbest = Len(S2) For word2 = LBound(wordsS2) To UBound(wordsS2) thisD = LevenshteinDistance(wordsS1(word1), wordsS2(word2)) If thisD < wordbest Then wordbest = thisD If thisD = 0 Then GoTo foundbest Next word2 foundbest: wordsTotal = wordsTotal + wordbest Next word1 valueWords = wordsTotal End Function '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' ' SplitMultiDelims ' Bu işlev, Metni her biri DelimChars'daki herhangi bir karakterle sınırlandırılmış alt dizelerden oluşan bir diziye böler. Yalnızca tek bir karakter iki alt dize arasında sınırlayıcı olabilir, ancak DelimChars herhangi sayıda sınırlayıcı karakter içerebilir. DelimChars boşsa metnin tamamını içeren tek bir öğeli bir dizi döndürür veya Metin başarıyla alt dizelere bölünürse 1 veya daha fazla öğeli bir dizi döndürür. ' IgnoreConsecutiveDelimiters true ise, boş dizi öğeleri oluşmaz. ' Limit 0'dan büyükse, işlev Metni yalnızca 'Limit' dizi öğesine veya daha azına böler. Son öğe Metnin geri kalanını içerir. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' Function SplitMultiDelims(ByRef Text As String, ByRef DelimChars As String, _ Optional ByVal IgnoreConsecutiveDelimiters As Boolean = False, _ Optional ByVal Limit As Long = -1) As String() Dim ElemStart As Long, N As Long, M As Long, Elements As Long Dim lDelims As Long, lText As Long Dim Arr() As String lText = Len(Text) lDelims = Len(DelimChars) If lDelims = 0 Or lText = 0 Or Limit = 1 Then ReDim Arr(0 To 0) Arr(0) = Text SplitMultiDelims = Arr Exit Function End If ReDim Arr(0 To IIf(Limit = -1, lText - 1, Limit)) Elements = 0: ElemStart = 1 For N = 1 To lText If InStr(DelimChars, Mid(Text, N, 1)) Then Arr(Elements) = Mid(Text, ElemStart, N - ElemStart) If IgnoreConsecutiveDelimiters Then If Len(Arr(Elements)) > 0 Then Elements = Elements + 1 Else Elements = Elements + 1 End If ElemStart = N + 1 If Elements + 1 = Limit Then Exit For End If Next N 'Dizenin sonuyla sonlandırılan son belirteci diziye alın If ElemStart <= lText Then Arr(Elements) = Mid(Text, ElemStart) 'Dizenin sonu sonlandırıcı sınırlayıcı olarak sayıldığından, son karakter de bir sınırlayıcıysa, ikisini ardışık olarak ele alırız ve bu nedenle son öğeyi yoksayarız If IgnoreConsecutiveDelimiters Then If Len(Arr(Elements)) = 0 Then Elements = Elements - 1 ReDim Preserve Arr(0 To Elements) 'Kullanılmayan dizi öğelerini kesin SplitMultiDelims = Arr End Function ``` Bu iki ölçütü ve iki dize arasındaki mesafeyi hesaplayan üçüncü bir ölçütü kullanarak, en fazla eşleşmeyi elde etmek için bir optimizasyon algoritması çalıştırabileceğimiz bir dizi değişkenimiz var. Belirsiz dize eşleştirme, kendi başına belirsiz bir bilimdir ve bu nedenle dize benzerliğini ölçmek için doğrusal olarak bağımsız ölçütler oluşturarak ve birbirine eşleştirmek istediğimiz bilinen bir dize kümesine sahip olarak, belirli dize stillerimiz için en iyi belirsiz eşleşme sonuçlarını veren parametreleri bulabiliriz. Belirsiz eşleştirmenin optimizasyonuna izin vermek için her ölçütü ağırlıklandırabiliriz. Son puanı tanımlayan formül, ölçütlerin ve ağırlıklarının basit bir birleşimidir: ``` value = Min(phraseWeight*phraseValue, wordsWeight*wordsValue)*minWeight + Max(phraseWeight*phraseValue, wordsWeight*wordsValue)*maxWeight + lengthWeight*lengthValue ``` Özel bağlamınız için, benzerliği belirlemek için ortaya koyduğunuz herhangi bir ölçüt için bir dizi ağırlık bulmanız gerekir. Uygun bir sezgi ve ağırlık kümesiyle, karşılaştırma programınız sizin vereceğiniz kararları hızla verecektir.

Given the following code: ```var arr = [1,2,3,4,5]; var results: number[] = await arr.map(async (item): Promise => { await callAsynchronousOperation(item); return item + 1; }); ``` which produces the following error: TS2322: Type 'Promise[]' is not assignable to type 'number[]'. Type 'Promise is not assignable to type 'number'. How can I fix it? How can I make ```async await``` and ```Array.map``` work together?

Aşağıdaki kodu göz önünde bulundurun: ```var arr = [1,2,3,4,5]; var results: number[] = await arr.map(async (item): Promise => { await callAsynchronousOperation(item); return item + 1; }); ``` Aşağıdaki hatayı üreten: TS2322: 'Promise[]' türü 'number[]' türüne atanabilir değil. 'Promise' türü 'number' türüne atanabilir değil. Nasıl düzeltebilirim? ```async await``` ve ```Array.map```'in birlikte çalışmasını nasıl sağlayabilirim?

The problem here is that you are trying to ```await``` an array of promises rather than a Promise. This doesn't do what you expect. When the object passed to ```await``` is not a Promise, ```await``` simply returns the value as-is immediately instead of trying to resolve it. So since you passed ```await``` an array (of Promise objects) here instead of a Promise, the value returned by await is simply that array, which is of type ```Promise[]```. What you probably want to do is call ```Promise.all``` on the array returned by ```map``` in order to convert it to a single Promise before ```await```ing it. According to the MDN docs for ```Promise.all```: The ```Promise.all(iterable)``` method returns a promise that resolves when all of the promises in the iterable argument have resolved, or rejects with the reason of the first passed promise that rejects. So in your case: ```var arr = [1, 2, 3, 4, 5]; var results: number[] = await Promise.all(arr.map(async (item): Promise => { await callAsynchronousOperation(item); return item + 1; })); ``` This will resolve the specific error you are encountering here. Depending on exactly what it is you're trying to do you may also consider using ```Promise.allSettled```, ```Promise.any```, or ```Promise.race``` instead of ```Promise.all```, though in most situations (almost certainly including this one) ```Promise.all``` will be the one you want.

Buradaki sorun, bir Promise yerine bir promise dizisini ```await``` etmeye çalışmanızdır. Bu, beklediğiniz şeyi yapmaz. ```await```'e geçirilen nesne bir Promise olmadığında, ```await``` çözmeye çalışmak yerine değeri olduğu gibi hemen döndürür. Bu nedenle, bir Promise yerine burada ```await```'e bir dizi (Promise nesnelerinden oluşan) geçirdiğinizden, await tarafından döndürülen değer, ```Promise[]``` türünde olan bu dizidir. Muhtemelen yapmak istediğiniz şey, ```await``` etmeden önce tek bir Promise'e dönüştürmek için ```map``` tarafından döndürülen dizi üzerinde ```Promise.all``` çağırmaktır. ```Promise.all``` için MDN belgelerine göre: ```Promise.all(iterable)``` yöntemi, iterable bağımsız değişkenindeki tüm promise'ler çözüldüğünde çözülen veya reddeden ilk promise'in nedeniyle reddedilen bir promise döndürür. Yani sizin durumunuzda: ```var arr = [1, 2, 3, 4, 5]; var results: number[] = await Promise.all(arr.map(async (item): Promise => { await callAsynchronousOperation(item); return item + 1; })); ``` Bu, burada karşılaştığınız belirli hatayı çözecektir. Tam olarak ne yapmaya çalıştığınıza bağlı olarak, ```Promise.all``` yerine ```Promise.allSettled```, ```Promise.any``` veya ```Promise.race``` kullanmayı da düşünebilirsiniz, ancak çoğu durumda (neredeyse kesinlikle bu da dahil) ```Promise.all``` istediğiniz olacaktır.

Why don't helicopters use reaction wheels to counter the main rotor?

Helikopterler neden ana rotoru dengelemek için tepki tekerlekleri kullanmaz?

You're talking about a device (in helicopters the tail fan imparting horizontal thrust) that counteracts the torque imparted on the main rotor (and therefore on the helicopter) by the surrounding air as the main rotor is dragged through the air. You propose instead to impart an opposite torque through a reaction wheel. That would indeed impart an opposite torque for short lengths of time. However, you don't get a torque from spinning a reaction wheel at constant angular velocity but by changing and accelerating that angular velocity. Now the torque imparted on the helicopter by the air through the main rotor is steady - or at least its of roughly constant direction. Therefore, to counter that torque, the reaction wheel would have to accelerated uniformly and indefinitely. Clearly this is impossible from an engineering standpoint. You can also think of this from a conservation of angular momentum, without thinking about the origin of the torques. The air imparts a steady angular impulse to the helicopter. Therefore, the helicopter system's angular momentum must increase steadily (unless there's a countering torque from the tailfan). So either that angular momentum is the spinning of the helicopter's body (which is what we're trying to avoid) or that of the reaction wheel, whose angular momentum must be steadily increasing under the action of the angular impulse to the system.

Helikopterlerde yatay itki veren kuyruk fanının, ana rotorun (ve dolayısıyla helikopterin) etrafındaki hava tarafından ana rotor havada sürüklenirken uygulanan torku etkisiz hale getiren bir cihazdan bahsediyorsunuz. Bunun yerine bir tepki çarkı aracılığıyla zıt bir tork uygulamayı öneriyorsunuz. Bu, gerçekten de kısa süreler için zıt bir tork uygular. Ancak, bir tepki çarkını sabit açısal hızda döndürmekten değil, bu açısal hızı değiştirmek ve hızlandırmaktan tork elde edersiniz. Şimdi, havanın ana rotor aracılığıyla helikoptere uyguladığı tork sabittir - veya en azından yaklaşık olarak sabit yönlüdür. Bu nedenle, bu torku etkisiz hale getirmek için tepki çarkının düzgün ve süresiz olarak hızlandırılması gerekir. Bunun mühendislik açısından imkansız olduğu açıktır. Bunun hakkında torkların kökenini düşünmeden, açısal momentumun korunumu açısından da düşünebilirsiniz. Hava, helikoptere sabit bir açısal dürtü uygular. Bu nedenle, helikopter sisteminin açısal momentumu sürekli olarak artmalıdır (kuyruk fanından karşıt bir tork olmadığı sürece). Yani ya bu açısal momentum helikopter gövdesinin dönmesidir (kaçınmaya çalıştığımız şey budur) ya da sistemdeki açısal dürtü etkisinde açısal momentumu sürekli artması gereken tepki çarkının dönmesidir.

When configuring cron to run a command every other day using the "Day of Month" field, like so: ```1 22 */2 * * COMMAND ``` it runs every time the day of month is odd: 1,3,5,7,9 and so on. How can I configure cron to run on days of month that are even like 2,6,8,10 and so on (without specifying it literally, which is problematic as every month has a different number of days in the month)?

Cron'u "Ayın Günü" alanını kullanarak her iki günde bir komut çalıştıracak şekilde yapılandırırken, şöyle: ```1 22 */2 * * COMMAND ``` ayın günü tek olduğunda her zaman çalışır: 1,3,5,7,9 vb. Cron'u ayın günü çift olan 2,6,8,10 vb. günlerde çalışacak şekilde nasıl yapılandırabilirim (her ayın ayda farklı sayıda günü olduğu için bunu tam olarak belirtmeden)?

The syntax you tried is actually ambiguous. Depending on how many days are in the month, some months it will run on odd days and some on even. This is because the way it is calculated takes the total number of possibilities and divides them up. You can override this strage-ish behavior by manually specifying the day range and using either an odd or even number of days. Since even day scripts would never run on the 31st day of longer months, you don't lose anything using 30 days as the base for even-days, and by specifying specifically to divide it up as if there were 31 days you can force odd-day execution. The syntax would look like this: ```# Will only run on odd days: 0 0 1-31/2 * * command # Will only run on even days: 0 0 2-30/2 * * command ``` Your concern about months not having the same number of days is not important here because no months have MORE days than this, and for poor February, the date range just won't ever match the last day or two, but it will do no harm having it listed. The only 'gotcha' for this approach is that if you are on an odd day cycle, following months with 31 days your command will also run on the first of the month. Likewise if you are forcing an even cycle, each leap year will cause one three-day cycle at the end of February. You cannot really get around the fact that any regular pattern of "every other day" is not always going to fall on even or odd days in every month and any way you force this you will either have an extra run or be missing a run between months with mismatched day counts.

Denediğiniz söz dizimi aslında belirsizdir. Ayda kaç gün olduğuna bağlı olarak, bazı aylarda tek günlerde, bazılarında ise çift günlerde çalışacaktır. Bunun nedeni, hesaplanma şeklinin toplam olasılık sayısını alıp bunları bölmesidir. Gün aralığını manuel olarak belirleyerek ve tek veya çift sayıda gün kullanarak bu garip davranışı geçersiz kılabilirsiniz. Çift günlü komut dosyaları daha uzun ayların 31. gününde asla çalışmayacağından, çift günler için taban olarak 30 gün kullanarak hiçbir şey kaybetmezsiniz ve 31 gün varmış gibi bölmeyi özellikle belirterek tek gün yürütmeyi zorlayabilirsiniz. Söz dizimi şöyle görünecektir: ```# Yalnızca tek günlerde çalışır: 0 0 1-31/2 * * komut # Yalnızca çift günlerde çalışır: 0 0 2-30/2 * * komut ``` Ayların aynı sayıda güne sahip olmamasıyla ilgili endişeniz burada önemli değildir çünkü hiçbir ay bundan DAHA fazla güne sahip değildir ve zavallı Şubat için tarih aralığı son bir veya iki günle asla eşleşmeyecektir, ancak listelenmesinin bir zararı olmayacaktır. Bu yaklaşım için tek 'tuzak', tek gün döngüsündeyken, 31 günlük ayları takip eden komutunuzun ayın birinde de çalışacağıdır. Aynı şekilde, bir çift döngü zorluyorsanız, her artık yıl Şubat ayının sonunda üç günlük bir döngüye neden olacaktır. "Her iki günde bir" düzenli bir kalıbın her ayda her zaman tek veya çift günlere denk gelmeyeceği gerçeğinden gerçekten kaçamazsınız ve bunu zorladığınız her şekilde, eşleşmeyen gün sayılarına sahip aylar arasında fazladan bir çalışma yaparsınız veya bir çalışmayı kaçırırsınız.

Is there a way to have a private setter for a property in TypeScript? ```class Test { private _prop: string; public get prop() : string { return this._prop; } private set prop(val: string) { //can put breakpoints here this._prop = val; } } ``` Compiler complains that visibility for getter and setter don't match. I know I can just set the backing field, but but then I can't set breakpoints when the value is set. I though about using an interface to hide the setter, but interfaces can only define a property, not whether it has a getter on setter. Am I missing something here? There doesn't seem to be any reason to not allow private setters, the resulting JS doesn't enforce visibility anyway, and seems better that the current alternatives. Am I missing something? If not is there a good reason for no private setters?

TypeScript'te bir özelliğin özel bir ayarlayıcısına sahip olmanın bir yolu var mı? ```class Test { private _prop: string; public get prop() : string { return this._prop; } private set prop(val: string) { //buraya kesme noktaları koyabilirsin this._prop = val; } } ``` Derleyici, getter ve setter için görünürlüğün eşleşmediğinden şikayet ediyor. Sadece destek alanını ayarlayabileceğimi biliyorum, ancak o zaman değer ayarlandığında kesme noktaları ayarlayamıyorum. Setter'ı gizlemek için bir arayüz kullanmayı düşündüm, ancak arayüzler yalnızca bir özelliği tanımlayabilir, getter veya setter'a sahip olup olmadığını değil. Burada bir şey mi kaçırıyorum? Özel ayarlayıcılara izin verilmemesinin bir nedeni yok gibi görünüyor, ortaya çıkan JS zaten görünürlüğü zorlamıyor ve mevcut alternatiflere göre daha iyi görünüyor. Bir şey mi kaçırıyorum? Değilse, özel ayarlayıcıların olmamasının iyi bir nedeni var mı?

The TypeScript specification (8.4.3) says" Accessors for the same member name must specify the same accessibility So you have to choose a suitable alternative. Here are two options for you: You can just not have a setter, which means only the ```Test``` class is able to set the property. You can place a breakpoint on the line ```this._prop =...```. ```class Test { private _prop: string; public get prop() : string { return this._prop; } doSomething() { this._prop = 'I can set it!'; } } var test = new Test(); test._prop = 'I cannot!'; ``` Probably the ideal way to ensure private access results in something akin to a "notify property changed" pattern can be implemented is to have a pair of private get/set property accessors, and a separate public get property accessor. You still need to be cautious about someone later adding a direct call to the backing field. You could get creative in that area to try and make it less likely. ```class Test { private _nameBackingField: string; private get _name() : string { return this._nameBackingField; } private set _name(val: string) { this._nameBackingField = val; // other actions... notify the property has changed etc } public get name(): string { return this._name; } doSomething() { this._name += 'Additional Stuff'; } } ```

TypeScript spesifikasyonu (8.4.3) şöyle der: Aynı üye adı için erişimciler aynı erişilebilirliği belirtmelidir Bu nedenle uygun bir alternatif seçmeniz gerekir. İşte sizin için iki seçenek: Sadece bir ayarlayıcıya sahip olmayabilirsiniz, bu da yalnızca ```Test``` sınıfının özelliği ayarlayabileceği anlamına gelir. ```this._prop =...``` satırına bir kesme noktası yerleştirebilirsiniz. ```class Test { private _prop: string; public get prop() : string { return this._prop; } doSomething() { this._prop = 'I can set it!'; } } var test = new Test(); test._prop = 'I cannot!'; ``` Muhtemelen özel erişimin "özellik değiştirildi bildirimi" kalıbına benzer bir şeyle sonuçlanmasını sağlamanın ideal yolu, bir çift özel get/set özellik erişimcisi ve ayrı bir genel get özellik erişimcisi kullanmaktır. Daha sonra birinin destek alanına doğrudan bir çağrı eklemesi konusunda yine de dikkatli olmanız gerekir. Bunu daha az olası hale getirmek için o alanda yaratıcı olabilirsiniz. ```class Test { private _nameBackingField: string; private get _name() : string { return this._nameBackingField; } private set _name(val: string) { this._nameBackingField = val; // diğer eylemler... özelliğin değiştiğini bildirme vb. } public get name(): string { return this._name; } doSomething() { this._name += 'Additional Stuff'; } } ```

When learning vocabulary, especially with the use of SRS (Spaced Repetition System), it is interesting to use flashcards. A commonly encountered problem is how to formulate those for maximum efficiency. How does learning vocabulary through sentences, thus giving context to the used words, compare to learning to recognize words alone? For example, the context may give away the meaning of the problematic vocabulary. Are there studies or expert opinions on one approach being preferable to the other at different stages of language learning? Or is it recommended that they be mixed for best results?

Özellikle SRS (Aralıklı Tekrar Sistemi) kullanımıyla kelime öğrenirken, fiş kartları kullanmak ilginçtir. Sık karşılaşılan bir sorun, bunları maksimum verimlilik için nasıl formüle edeceğimizdir. Cümleler aracılığıyla kelime öğrenmek, böylece kullanılan kelimelere bağlam vermek, kelimeleri tek başına tanımayı öğrenmekle nasıl karşılaştırılır? Örneğin, bağlam, sorunlu kelime dağarcığının anlamını ortaya çıkarabilir. Dil öğreniminin farklı aşamalarında bir yaklaşımın diğerine tercih edilmesi konusunda çalışmalar veya uzman görüşleri var mı? Yoksa en iyi sonuçlar için karıştırılmaları mı önerilir?

It's usually best to avoid dichotomies like "Is strategy X better or strategy Y better?". In most cases, strategies are not mutually exclusive but complementary. With vocabulary learning, using just one strategy is probably the least efficient. This is because every strategy has certain strengths (certain skills it builds well) and certain weaknesses (skills it doesn't cover well)- and if you keep using one strategy, you'll be only focusing on the strengths (but with diminishing returns), and not addressing the weaknesses. Using flashcards helps you establish word-to-meaning equivalences quickly, but it usually does so with a shallow meaning, ignoring the breadth of meaning that words usually have. It also ignores the contextual subtleties of the word, and the knowledge is not always retained long-term. It's best to combine flashcards with other strategies that will help you see how the word is used in context, show you the variety of meanings it can have (and doesn't have), see what collocations the word has, etc. One way of doing this is by reading examples of the word and writing your own sample sentences. Another important thing is to be exposed to the word in natural settings - so it's important to read a lot so that you'll encounter the words you've learnt naturally.

"X stratejisi mi yoksa Y stratejisi mi daha iyi?" gibi ikili karşıtlıklardan kaçınmak genellikle en iyisidir. Çoğu durumda, stratejiler birbirini dışlamaz, birbirini tamamlar. Kelime öğrenirken, yalnızca bir strateji kullanmak muhtemelen en az verimli olanıdır. Bunun nedeni, her stratejinin belirli güçlü yönleri (iyi geliştirdiği belirli beceriler) ve belirli zayıf yönleri (iyi kapsamadığı beceriler) olmasıdır ve tek bir strateji kullanmaya devam ederseniz, yalnızca güçlü yönlere odaklanırsınız (ancak azalan getirilerle) ve zayıf yönleri ele almazsınız. Kelime kartları kullanmak, kelime-anlam eşdeğerliklerini hızlı bir şekilde oluşturmanıza yardımcı olur, ancak bunu genellikle kelimelerin genellikle sahip olduğu anlam genişliğini göz ardı ederek, yüzeysel bir anlamla yapar. Ayrıca kelimenin bağlamsal inceliklerini de göz ardı eder ve bilgi her zaman uzun vadede tutulmaz. Kelime kartlarını, kelimenin bağlamda nasıl kullanıldığını görmenize yardımcı olacak, sahip olabileceği (veya sahip olmadığı) anlam çeşitliliğini gösteren, kelimenin hangi eşleşmelere sahip olduğunu vb. gösteren diğer stratejilerle birleştirmek en iyisidir. Bunu yapmanın bir yolu, kelimenin örneklerini okumak ve kendi örnek cümlelerinizi yazmaktır. Bir diğer önemli şey, kelimenin doğal ortamlarda karşınıza çıkmasıdır - bu nedenle kelimeleri doğal olarak öğrendiğinizle karşılaşmak için çok fazla okumak önemlidir.

Can I spend the night alone in a tent in a forest outside Stockholm in -20°C without risking my life? The backstory From the end of January, I'm starting my studies in a suburb of Stockholm. I've decided to, if it turns out plausible, not rent an apartment, but live in a tent. (This is not out of frugality, but out of a will to try something new.) I do have friends who I could visit once a week or so to prepare food and wash my clothes, so I think I can solve the practical problems, or at least those that I've come to think of. I'd camp in one of the forests, maybe 1 km from "civilisation". I'd have access to showers etc at university every day. However: I don't want to freeze to death in my sleep! That's very important to me. I've read that the nights can get as cold as -20°C (-4°F). With the proper preparations, would this be a plausible way of living, at least for a month or so? I do have camping experience, and have been hiking for three weeks, but only in summer.

-20°C'de Stockholm dışındaki bir ormanda bir çadırda tek başıma geceyi geçirebilir miyim? Arka plan Ocak ayının sonundan itibaren Stockholm'ün bir banliyösünde eğitimime başlayacağım. Mümkün olursa bir daire kiralamayıp bir çadırda yaşamaya karar verdim. (Bu tutumluluktan değil, yeni bir şey deneme isteğinden kaynaklanıyor.) Haftada bir veya daha sık yemek hazırlamak ve çamaşırlarımı yıkamak için ziyaret edebileceğim arkadaşlarım var, bu yüzden pratik sorunları çözebileceğimi düşünüyorum ya da en azından aklıma gelenleri. "Medeniyetten" belki 1 km uzaklıktaki ormanlardan birinde kamp kuracağım. Üniversitede her gün duş vb. olanaklara erişimim olacak. Ancak: Uyurken donarak ölmek istemiyorum! Bu benim için çok önemli. Gecelerin -20°C (-4°F) kadar soğuyabileceğini okudum. Uygun hazırlıklarla, en azından bir ay kadar bu şekilde yaşamak mümkün mü? Kamp deneyimim var ve üç hafta boyunca yürüyüş yaptım ama sadece yaz aylarında.

Yes, it is definitely doable. -20&deg;C is only -4&deg;F. The real question is whether it is doable by you at the level of discomfort and hassle you are willing to put up with. Only you can answer that. At best we can point out what the hassles and discomforts will be. First, your fear of dying of cold in your sleep is silly. You'd have to do something pretty stupid to die of hypothermia, and even that's not going to happen when you're inside the sleeping bag. The main danger will be from frostbite, but that again would largely need stupidity to help it along, although that's easier to do than outright death from hypothermia. Your tent will be a long term fixed installation you set up once at a time and conditions of your choosing. You can therefore afford a larger and heavier tent with more stuff you bring in once. Definitely get a tent you can stand upright in. That will make changing clothes much quicker and more comfortable. Since you should be able to keep water out of the tent, get a nice down sleeping bag and a few light blankets. The down bag should be rated for most nights, then put the blankets on top for the few unusually cold nights. Since again weight is not really a issue, get a full sleeping bag, not a mummy bag. They are simply more comfortable. Get a good insulating pad, and another two as backup. Get a tent large enough to fit your sleeping bag and something to sit on next to it, like a folding chair. Put something under the legs to spread out the weight to that they don't hurt the tent floor. Get one of those rubber-backed mats people sometimes put just inside their doors and put it just inside your tent. That allows a place to step with boots still on, then you can sit down on the chair with boots still on the mat to take them off. The crud stays on the mat, which you can shake clean by reaching outside after having put on your down hut booties. Some things are going to be a hassle. At -4&deg;F you want to keep your gloves on whenever possible, but some tasks will be difficult that way. You end up taking your gloves on and off a lot, trading off efficiency with cold fingers. Get a pair of polypro glove liners. They are thin and still allow many tasks to be done, but provide at least a little insulation. Their main advantage is that any metal you touch won't immediately conduct the heet from your hand away. Touching bare metal at -4&deg;F is a good way to get frostbite. Be prepared for some discomfort no matter what equipment you have. The toughest part will be getting yourself out of the sleeping bag in the morning. You'll really have to will yourself to leave the warm comfort of the bag and get into the air at probably the coldest part of the day. At some point you'll have to change your clothes and get undressed in the process. That's going to be cold. It won't be cold long enough to be any real danger, so it's really a mindset issue to get over. Whether you can or not and are willing to push yourself in that way only you can say. You say you have access to heated buildings during the day, so it would make things a lot simpler for you if you don't have to deal with cooking and eating at your camp. Perparing food outside in the cold takes a lot longer than in a heated kitchen, severly limits what you can do, and may also risk predator encounters depending on what is around your area in the winter.

Evet, kesinlikle yapılabilir. -20&deg;C sadece -4&deg;F'dir. Asıl soru, sizin için rahatsızlık ve uğraş seviyesinde yapılıp yapılamayacağıdır. Bunu yalnızca siz cevaplayabilirsiniz. En iyi ihtimalle, uğraşların ve rahatsızlıkların ne olacağını belirtebiliriz. İlk olarak, uykunuzda soğuktan ölme korkunuz saçma. Hipotermiden ölmek için oldukça aptalca bir şey yapmanız gerekir ve uyku tulumunun içindeyken bile bu gerçekleşmeyecektir. Başlıca tehlike donma olacaktır, ancak bu da yine büyük ölçüde aptallığa ihtiyaç duyar, ancak bu, hipotermiden tamamen ölmekten daha kolaydır. Çadırınız, bir seferde ve seçtiğiniz koşullarda kurduğunuz uzun vadeli sabit bir kurulum olacaktır. Bu nedenle, bir seferde daha fazla eşya getirebileceğiniz daha büyük ve daha ağır bir çadır alabilirsiniz. Kesinlikle içinde dik durabildiğiniz bir çadır alın. Bu, kıyafet değiştirmeyi çok daha hızlı ve rahat hale getirecektir. Çadırdan suyu uzak tutabilmeniz gerektiğinden, güzel bir kaz tüyü uyku tulumu ve birkaç hafif battaniye alın. Kaz tüyü tulum çoğu gece için derecelendirilmelidir, ardından alışılmadık derecede soğuk geceler için battaniyeleri üstüne koyun. Yine ağırlık gerçekten bir sorun olmadığından, mumya tulum değil, tam bir uyku tulumu alın. Basitçe daha rahattırlar. İyi bir yalıtım pedi ve yedek olarak iki tane daha alın. Uyku tulumunuza ve yanına oturacak bir şey, örneğin katlanır bir sandalye sığacak kadar büyük bir çadır alın. Çadır tabanına zarar vermemeleri için ağırlığı dağıtmak üzere bacakların altına bir şey koyun. İnsanların bazen kapılarının hemen içine koydukları kauçuk destekli paspaslardan birini alın ve çadırınızın hemen içine koyun. Bu, botlarınız hala giyiliyken adım atacak bir yer sağlar, ardından botlarınız hala paspasın üzerindeyken onları çıkarmak için sandalyeye oturabilirsiniz. Çamur paspasın üzerinde kalır ve kaz tüyü patiklerinizi giydikten sonra dışarı uzanarak temizleyebilirsiniz. Bazı şeyler zahmetli olacaktır. -4&deg;F'de mümkün olduğunca eldivenlerinizi takmak istersiniz, ancak bazı görevler bu şekilde zor olacaktır. Eldivenlerinizi çok fazla takıp çıkararak, soğuk parmaklarla verimliliği değiştirirsiniz. Bir çift polipropilen eldiven astarı alın. İnce ve yine de birçok görevin yapılmasına izin verirler, ancak en azından biraz yalıtım sağlarlar. Başlıca avantajları, dokunduğunuz herhangi bir metalin elinizden gelen ısıyı hemen iletmemesidir. -4&deg;F'de çıplak metale dokunmak donma için iyi bir yoldur. Hangi ekipmana sahip olursanız olun biraz rahatsızlığa hazırlıklı olun. En zor kısım, sabah uyku tulumundan çıkmaktır. Günün muhtemelen en soğuk kısmında tulumun sıcak rahatlığından ayrılmak ve havaya girmek için kendinizi gerçekten zorlamanız gerekecek. Bir noktada kıyafetlerinizi değiştirmeniz ve bu süreçte soyunmanız gerekecek. Bu soğuk olacak. Gerçek bir tehlike oluşturacak kadar uzun sürmeyecek, bu yüzden üstesinden gelmek için gerçekten bir zihniyet meselesi. Bunu yapıp yapamayacağınızı ve kendinizi bu şekilde zorlamaya istekli olup olmadığınızı yalnızca siz söyleyebilirsiniz. Gün içinde ısıtmalı binalara erişiminiz olduğunu söylüyorsunuz, bu nedenle kampınızda yemek pişirme ve yemekle uğraşmak zorunda kalmazsanız işler sizin için çok daha kolay olacaktır. Soğukta dışarıda yemek hazırlamak, ısıtılmış bir mutfakta yemek hazırlamaktan çok daha uzun sürer, yapabileceklerinizi ciddi şekilde sınırlar ve kışın bölgenizde ne olduğuna bağlı olarak yırtıcı hayvanlarla karşılaşma riski de olabilir.

Why is the volt not identical to the full name Volta, unlike the other electrical units ohm, ampere, coulomb, tesla, weber and henry? Is there a historical explanation, was the volt introduced at a different time?

Volt, ohm, amper, coulomb, tesla, weber ve henry gibi diğer elektrik birimlerinden farklı olarak neden Volta'nın tam adıyla aynı değil? Tarihsel bir açıklaması var mı, volt farklı bir zamanda mı getirildi?

The volt, ohm and farad were introduced by the same person, Latimer Clark, a cable engineer, in a paper in 1861. He started the tradition of naming units after scientists. He initially distorted all names: the unit names ohma, volt, galvat (from Galvani), and farad (from Faraday). In his words, he "neglected etymological rules". In that same year, a committee of the British Association for the Advancement of Science began developing a coherent system of electrical units, the cgs system. Varley, a committee member, liked Clark's proposal, but he advocated adding a French name such as Ampere, to facilitate the international acceptance of the new units ("I should like to introduce a French name into the list. We have Germany, England and Italy represented"). For the same reason he may have pleaded for not distorting the French and German names. In addition, Varley objected to the galvat "because Galvani discovered next to nothing". Latimer Clark adapted the unit names in his 'Elementary treatise on electrical measurement' (1868). He changed ohma to ohm, and dropped the galvat. Maxwell acknowledged Clark's practical units and their names in his 'Treatise on electricity and magnetism' (1873). In 1881, at the International Electrical Congress in Paris), two French names, ampere and coulomb, were added. The diplomacy worked, and the new system of electrical units was adopted by all countries. The only units that kept the initial name distortion were the volt and the farad.

Volt, ohm ve farad, 1861'de bir kablo mühendisi olan Latimer Clark tarafından aynı makalede tanıtıldı. Birimlere bilim insanlarının adını verme geleneğini başlattı. Başlangıçta tüm isimleri bozdu: ohma, volt, galvat (Galvani'den) ve farad (Faraday'dan) birim isimleri. Kendi sözleriyle, "etimolojik kuralları ihmal etti". Aynı yıl, British Association for the Advancement of Science'ın bir komitesi, cgs sistemi olan tutarlı bir elektrik birimleri sistemi geliştirmeye başladı. Komite üyesi Varley, Clark'ın önerisini beğendi, ancak yeni birimlerin uluslararası kabulünü kolaylaştırmak için Ampere gibi bir Fransız adı eklenmesini savundu ("Listeye bir Fransız adı eklemek istiyorum. Almanya, İngiltere ve İtalya temsil ediliyor"). Aynı nedenle Fransızca ve Almanca isimleri bozmamak için yalvarmış olabilir. Ayrıca Varley, "Galvani neredeyse hiçbir şey keşfetmediği için" galvat'a itiraz etti. Latimer Clark, 'Elementary treatise on electrical measurement' (1868) adlı eserinde birim isimlerini uyarladı. Ohma'yı ohm olarak değiştirdi ve galvat'ı kaldırdı. Maxwell, 'Treatise on electricity and magnetism' (1873) adlı eserinde Clark'ın pratik birimlerini ve isimlerini kabul etti. 1881'de Paris'teki Uluslararası Elektrik Kongresi'nde ampere ve coulomb olmak üzere iki Fransız adı eklendi. Diplomasi işe yaradı ve yeni elektrik birimleri sistemi tüm ülkeler tarafından kabul edildi. İlk isim bozulmasını koruyan tek birimler volt ve farad'dı.

We can define cross products mathematically like if we take two vectors, we can find another vector with certain properties but why do we use it in physics, if we consider a hypothetical physical quantity like force which is equal to cross product of certain vectors? For example, the force exerted on a charge in motion in an uniform magnetic field. Why is it so? Why does that force have to be a cross product of two vectors? Is it possible to come up with them when what we do is just observe the nature?

Çarpım işlemlerini matematiksel olarak tanımlayabiliriz, iki vektör alırsak belirli özelliklere sahip başka bir vektör bulabiliriz ama fizikte neden kullanırız, kuvvet gibi belirli vektörlerin çarpımına eşit olan varsayımsal bir fiziksel nicelik düşünürsek? Örneğin, düzgün bir manyetik alanda hareket eden bir yük üzerinde uygulanan kuvvet. Neden böyle? Neden bu kuvvet iki vektörün çarpımı olmak zorunda? Sadece doğayı gözlemlediğimizde bunları bulmak mümkün mü?

This is a great question. The dot and cross products seem very mysterious when they are first introduced to a new student. For example, why does the scalar (dot) product have a cosine in it and the vector (cross) product have a sine, rather than vice versa? And why do these same two very non-obvious ways of "multiplying" vectors together arise in so many different contexts? The fundamental answer (which unfortunately may not be very accessible if you're a new student) is that there are only two algebraically independent tensors that are invariant under arbitrary rotations in $n$ dimensions (we say that they are "$\mathrm{SO}(n)$ invariant"). These are the Kronecker delta $\delta_{ij}$ and the Levi-Civita symbol $\epsilon_{ijk \cdots}$. Contracting two vectors with these symbols yields the dot and cross products, respectively (the latter only works in three dimensions). Since the laws of physics appear to be isotropic (i.e. rotationally invariant), it makes sense that any physically useful method for combining physical quantities like vectors together should be isotropic as well. The dot and cross products turn out to be the only two possible multilinear options. Why multilinear maps are so useful in physics is an even deeper and more fundamental question, but which answers to that question are satisfying is probably inherently a matter of opinion.

Bu harika bir soru. Nokta ve çarpım ürünleri, yeni bir öğrenciye ilk tanıtıldıklarında çok gizemli görünür. Örneğin, neden skaler (nokta) ürününde kosinüs varken vektör (çarpım) ürününde sinüs var, tam tersi değil? Ve neden vektörleri birlikte "çarpmanın" bu iki çok belirgin olmayan yolu bu kadar farklı bağlamda ortaya çıkıyor? Temel cevap (ne yazık ki yeni bir öğrenciyseniz pek erişilebilir olmayabilir), n boyutlarda keyfi dönüşümler altında değişmeyen yalnızca iki cebirsel olarak bağımsız tensörün olmasıdır (bunların "SO(n) değişmez" olduğunu söyleriz). Bunlar Kronecker deltası δij ve Levi-Civita sembolü εijk…'dir. İki vektörü bu sembollerle daraltmak sırasıyla nokta ve çarpım ürünlerini verir (ikincisi yalnızca üç boyutta çalışır). Fizik yasaları izotropik göründüğünden (yani dönmeyle değişmez), vektörler gibi fiziksel nicelikleri bir araya getirmek için fiziksel olarak yararlı herhangi bir yöntemin de izotropik olması mantıklıdır. Nokta ve çarpım ürünleri, olası iki çoklu doğrusal seçenek olarak ortaya çıkıyor. Çoklu doğrusal haritaların fizikte neden bu kadar yararlı olduğu daha da derin ve temel bir sorudur, ancak bu sorunun hangi cevapları tatmin edicidir, muhtemelen özünde bir fikir meselesidir.

I have a web project in my solution file that is "unavailable" when I open the solution. When I right-click on the web project and reload the project, I get the following error: ``` The Web Application Project mycompany.myapp.mywebproject is configured to use IIS. The Web Server 'http://localhost/MyWebApp could not be found. ``` I have not manually set up virtual directories for this web application. Per colleagues, Visual Studio should prompt me to create virtual directories but I am not getting prompted. I installed VS2010 before installing IIS on my dev machine. Here is my development machine setup: * Windows 7 Enterprise * Service Pack 1 * 64 bit OS * Visual Studio 2010 Enterprise Service pack 1 * IIS version 7.5

Çözüm dosyamda, çözümü açtığımda "kullanılamayan" bir web projem var. Web projesine sağ tıklayıp projeyi yeniden yüklediğimde şu hatayı alıyorum: ``` Web Uygulama Projesi mycompany.myapp.mywebproject, IIS kullanacak şekilde yapılandırıldı. Web Sunucusu 'http://localhost/MyWebApp' bulunamadı. ``` Bu web uygulaması için sanal dizinleri manuel olarak ayarlamadım. Meslektaşlarıma göre, Visual Studio sanal dizinler oluşturmam için bana sorgu sormalı ancak bana sorgu sorulmuyor. Geliştirme makinemde IIS'yi yüklemeden önce VS2010'u yükledim. İşte geliştirme makinem kurulumu: * Windows 7 Enterprise * Service Pack 1 * 64 bit işletim sistemi * Visual Studio 2010 Enterprise Service Pack 1 * IIS sürüm 7.5

When this happens the easiest solution is to make the virtual directory manually. First of all, you need to make sure you have the right version of ASP.Net installed and that you have installed the IIS extensions. To do this, go to the relevant .net version's folder in C:\(Windows)\Microsoft.NET\Framework\(dotnetver)\ (substituting the bracketed folders for the right folders on your PC) and run this command ```aspnet_regiis.exe -i ``` Next once that's run and finished, sometimes running ```iisreset ``` from the command line helps, sometimes you don't need to. Next, go to your IIS Manager and find you localhost website and choose add a folder. Browse to the folder in your project that contains the actual ASP.Net project and add that. Finally, right click on the folder you added and you should have an option that says 'convert to application' or 'create virtual directory' or something similar. Please make sure the Virtual directory has the name 'MyWebApp'!! Reload your solution and it should work. Good luck!

Bu gerçekleştiğinde en kolay çözüm sanal dizini manuel olarak oluşturmaktır. Her şeyden önce, doğru ASP.Net sürümünün yüklü olduğundan ve IIS uzantılarını yüklediğinizden emin olmanız gerekir. Bunu yapmak için C:\(Windows)\Microsoft.NET\Framework\(dotnetver)\ içindeki ilgili .net sürümü klasörüne gidin (parantez içindeki klasörleri bilgisayarınızdaki doğru klasörlerle değiştirin) ve şu komutu çalıştırın ```aspnet_regiis.exe -i ``` Ardından, bu komut çalıştırılıp bittikten sonra bazen komut satırından ```iisreset ``` komutunu çalıştırmak yardımcı olur, bazen de gerekmez. Ardından, IIS Yöneticinize gidin ve localhost web sitenizi bulun ve bir klasör eklemeyi seçin. ASP.Net projesini içeren projenizdeki klasöre gidin ve onu ekleyin. Son olarak, eklediğiniz klasöre sağ tıklayın ve 'uygulamaya dönüştür' veya 'sanal dizin oluştur' veya benzeri bir seçeneğiniz olmalıdır. Lütfen Sanal dizinin 'MyWebApp' adına sahip olduğundan emin olun!! Çözümünüzü yeniden yükleyin ve çalışması gerekir. İyi şanslar!

Why is it hard to draw people running in animes?

Animelerde koşan insanları çizmek neden zordur?

The walk cycle is considered to be one of the most basic aspects of animation. American animators and animation enthusiasts often times scorn the Japanese styles and methods of animation as lazy, while Japanese anime enthusiasts deride the American style as clunky or too comical. Why is that you ask? The answer lies in how these countries distribute their budget and time. While American animation often times may seem lacking in it's attention to detail, it makes up for it the quality of their animation. American animation often times meticulous and original in how they animate motion, though sometimes content is reused cyclically, the animation is painstakingly frame by frame. In contrast, Japanese anime uses a lot of shortcuts (to save budget and meet deadlines). Typically long scenes feature only the mouth of a character (and maybe other minor features like a waving hair or glittering eyes) moving during delivery of key information/dialog, or the short burst of motion of some character in some an action pose against an animated, cyclic, and stylized background (I'm looking at you transformation scenes). Often times these uses of dramatic still-shots are done against patterned (or static illustrated) backgrounds, sometimes a few moving emotive icons (sweat drops, question marks, small chibi animated heads) will accompany a some sort of monologue. Admittedly both styles of animation reuse shots and sequences, but it's more noticeable in Japanese anime for various reason (e.g., not enough budget and/or manpower). This is why Japanese anime is typically labeled as "lazy" by American animators and enthusiasts. A typical walk cycle in animation consists of 8 keyframes typically: The smoothness of an animation is typically determined by the framerate and amount of key frames in the animation. In American animation, the animation is captured by shooting two frames of film per drawing at a rate of 24 frames per second (fps) to achieve the smooth motion of American animation. Japanese anime, while it also runs at an average 24 fps, typically captures their animation at a rate of three or four frames per drawing in order to save money and manpower. Though it varies depending on the studio and tools used (e.g 3DCG) with main objects in the foreground (typically characters) are animated at 8 to 12 fps, while background objects can be animated at as low as 6 to 8 fps. Lets compare the difference between one walk cycle that is 8 frame to one that is 16 frames, both at 60 fps: Notice the 16 frame one is smoother, but slower while the 8 frame is faster, but choppier. This is because it takes the 16 frame animation twice as long, covering more frames, to go through one cycle than the 8 frame one. The varying of frame rates can also be be used to depict the expansion and compression of time (think bullet time from The Matrix). However generally choppy animation is the result of not enough keyframes in your animation. More frames mean more and manpower and/or time, which ultimately means more money is required. Japanese anime production don't typically have as big of a budget compared to American productions (but there are exceptions), so they must make do with what they have and cut corners where they can (like Shaft did with the certain Bakemonogatari TV episodes).

Yürüme döngüsü, animasyonun en temel yönlerinden biri olarak kabul edilir. Amerikalı animatörler ve animasyon meraklıları, Japon animasyon stillerini ve yöntemlerini genellikle tembel olarak küçümserken, Japon anime meraklıları Amerikan stilini beceriksiz veya fazla komik olarak alaya alır. Neden böyle olduğunu soruyorsunuz? Cevap, bu ülkelerin bütçelerini ve zamanlarını nasıl dağıttıklarında yatıyor. Amerikan animasyonu çoğu zaman ayrıntılara dikkat etmediği gibi görünse de, animasyonlarının kalitesiyle bunu telafi eder. Amerikan animasyonu, hareketleri canlandırma konusunda çoğu zaman titiz ve orijinaldir, ancak bazen içerik döngüsel olarak yeniden kullanılsa da, animasyon özenle kare kare yapılır. Buna karşılık, Japon anime bütçeden tasarruf etmek ve son teslim tarihlerine uymak için birçok kısayol kullanır. Tipik olarak uzun sahnelerde, anahtar bilgilerin/diyalogların verilmesi sırasında yalnızca bir karakterin ağzı (ve belki de sallanan saç veya parıldayan gözler gibi diğer küçük özellikler) hareket eder veya hareketli, döngüsel ve stilize bir arka plana karşı bir aksiyon pozunda bir karakterin kısa hareket patlaması (dönüşüm sahnelerine bakıyorum). Çoğu zaman bu dramatik durağan çekimler, desenli (veya statik çizimli) arka planlara karşı yapılır, bazen birkaç hareketli duygusal simge (ter damlaları, soru işaretleri, küçük chibi animasyonlu kafalar) bir tür monoloğa eşlik eder. Her iki animasyon stilinin de çekimleri ve sekansları yeniden kullandığı kabul edilmelidir, ancak çeşitli nedenlerden dolayı Japon animesinde daha belirgindir (örneğin, yetersiz bütçe ve/veya iş gücü). Bu nedenle Japon animeleri genellikle Amerikalı animatörler ve meraklıları tarafından "tembel" olarak etiketlenir. Animasyondaki tipik bir yürüyüş döngüsü genellikle 8 kilit kare içerir: Bir animasyonun akıcılığı genellikle animasyondaki kare hızına ve kilit kare sayısına göre belirlenir. Amerikan animasyonunda, animasyon, Amerikan animasyonunun akıcı hareketini elde etmek için saniyede 24 kare (fps) hızında çizim başına iki film karesi çekilerek yakalanır. Japon animeleri de ortalama 24 fps'de çalışırken, genellikle paradan ve iş gücünden tasarruf etmek için çizim başına üç veya dört kare hızında animasyonlarını yakalarlar. Kullanılan stüdyoya ve araçlara (örneğin 3DCG) bağlı olarak değişse de (ön plandaki ana nesneler (genellikle karakterler) 8 ila 12 fps'de, arka plan nesneleri ise 6 ila 8 fps kadar düşük bir hızda hareket ettirilir. 60 fps'de 8 kare olan bir yürüyüş döngüsü ile 16 kare olan bir yürüyüş döngüsü arasındaki farkı karşılaştıralım: 16 kare olanın daha akıcı ancak daha yavaş, 8 kare olanın ise daha hızlı ancak daha kesik olduğunu fark edin. Bunun nedeni, 16 karelik animasyonun 8 karelik animasyona göre bir döngüden geçmek için iki kat daha uzun sürmesi ve daha fazla kareyi kaplamasıdır. Kare hızlarının değiştirilmesi, zamanın genişlemesini ve sıkışmasını tasvir etmek için de kullanılabilir (The Matrix'teki mermi zamanını düşünün). Ancak genel olarak kesik animasyon, animasyonunuzda yeterince kilit kare olmamasının sonucudur. Daha fazla kare, daha fazla iş gücü ve/veya zaman anlamına gelir, bu da sonuçta daha fazla para gerektiği anlamına gelir. Japon anime prodüksiyonları genellikle Amerikan yapımlarına kıyasla o kadar büyük bir bütçeye sahip değildir (ancak istisnalar vardır), bu nedenle ellerindekilerle yetinmek ve yapabildikleri yerlerde köşe kesmek zorundadırlar (Shaft'ın belirli Bakemonogatari TV bölümlerinde yaptığı gibi).

Malachi 4:5: I will send you the prophet Elijah. He will come before the day of the Lord arrives. It will be a great and terrifying day Jesus says in Matthew 11:14 "and if you are willing to believe their message, John is Elijah, whose coming was predicted" Jesus says in Mathew 17:12 But I tell you, Elijah has already come, and they did not recognize him, but have done to him everything they wished. In the same way the Son of Man is going to suffer at their hands.” It's pretty clear from the above verses that John was Elijah reincarnated. Wouldn't the above verses imply that reincarnation is true?

Malaki 4:5: Size peygamber İlyas'ı göndereceğim. O, Rab'bin günü gelmeden önce gelecek. Bu büyük ve korkunç bir gün olacak. İsa Matta 11:14'te şöyle der: "Ve inanmaya istekliyseniz, Yahya, gelişi önceden bildirilen İlyas'tır." İsa Matta 17:12'de şöyle der: "Ama size şunu söyleyeyim, İlyas çoktan geldi ve onu tanımadılar, ama ona istedikleri her şeyi yaptılar. Aynı şekilde İnsanoğlu da onların elinden acı çekecek." Yukarıdaki ayetlerden Yahya'nın yeniden doğmuş İlyas olduğu oldukça açıktır. Yukarıdaki ayetler reenkarnasyonun doğru olduğunu ima etmiyor mu?

Faulty Premise #1: John the Baptist was a reincarnation of Elijah When Jesus asked Peter who people said he was, he answered that some people thought that Jesus was Elijah come back. Peter knew better and said Jesus was the Christ. In any event, John the Baptist himself directly denied the claim (see John 1:19-21). What Jesus more likely was saying in Matthew 11 is that John the Baptist was a prophet in the tradition of Elijah. Elijah was the greatest of the prophets (even if his disciple Elisha inherited a double portion of his spirit). All of the prophets that followed came in the name and spirit of Elijah, in the same way that some of Paul's letters apparently were created after his death. They were in the spirit and tradition even if not the actual man. Note also Elijah never died - he was taken up into heaven, and people thought he would return. As such, no Elijah was not being thought to have reincarnated- only returned. Elijah's return was long a part of Jewish custom. Even today, during a Passover sedar, a chair is left empty for Elijah. But again, since he did not die, Jews look for his return, not his reincarnation. Faulty Premise #2: The Jewish world view has any concept of reincarnation at all The most basic rule of hermeneutics suggests that a text cannot mean what it could not mean to the original audience. If the Jews had no concept of reincarnation, then any interpretation that says it does has a very, very high bar to clear. In his book The Gift of the Jews, Thomas Cahill advances the thesis that the primary distinctive philosophy of the Jews was precisely that history was not circular. Their linear idea of a human life was a departure from others and was an explicit rejection of reincarnation. As such, a text would need to be exceedingly explicit to a culture that rejected circular life patterns, and the obscure interpretation above (especially in light of the more obvious intepretation) simply doesn't hold water. Furthermore, the book of Hebrews - written to the people into which both Jesus and John the Baptist were born - explicitly reject reincarnation. As the writer points out in 9:27, It is appointed unto a man once to die and then the judgement. Here we do have an explicit rejection of reincarnation by the followers of Jesus. There is one death. There is one judgement. Hence, in any Christian worldview, you don't come back.

Hatalı Öncül #1: Vaftizci Yahya, İlyas'ın reenkarnasyonuydu İsa, Petrus'a insanların onun kim olduğunu söylediğini sorduğunda, bazı insanların İsa'nın geri dönen İlyas olduğunu düşündüğünü söyledi. Petrus daha iyi biliyordu ve İsa'nın Mesih olduğunu söyledi. Her durumda, Vaftizci Yahya iddiayı doğrudan reddetti (bkz. Yuhanna 1:19-21). İsa'nın Matta 11'de söylemek istediği şey, Vaftizci Yahya'nın İlyas geleneğinde bir peygamber olduğudur. İlyas, peygamberlerin en büyüğüydü (öğrencisi Elişa ruhunun iki katını miras alsa bile). Onu takip eden tüm peygamberler, İlyas'ın adına ve ruhuyla geldiler, tıpkı Pavlus'un mektuplarından bazılarının ölümünden sonra yazılmış olması gibi. Gerçek adam olmasalar bile ruh ve gelenek içindeydiler. Ayrıca İlyas'ın asla ölmediğini de unutmayın - cennete alındı ve insanlar onun geri döneceğini düşündü. Bu nedenle, İlyas'ın reenkarnasyon geçirdiği düşünülmüyordu - sadece geri dönmüştü. İlyas'ın dönüşü uzun zamandır Yahudi geleneğinin bir parçasıydı. Bugün bile, bir Fısıh sederi sırasında İlyas için bir sandalye boş bırakılır. Ancak yine de ölmediği için Yahudiler onun reenkarnasyonunu değil, dönüşünü beklerler. Hatalı Öncül #2: Yahudi dünya görüşünde reenkarnasyon kavramı vardır Hermenötiğin en temel kuralı, bir metnin orijinal okuyucu için ifade edemeyeceği bir anlama gelemeyeceğini öne sürer. Yahudilerin reenkarnasyon kavramı yoksa, bunu söyleyen herhangi bir yorumun aşması gereken çok, çok yüksek bir çıta vardır. Thomas Cahill, The Gift of the Jews adlı kitabında, Yahudilerin birincil ayırt edici felsefesinin tam da tarihin döngüsel olmadığı tezi olduğunu öne sürüyor. İnsan hayatına dair doğrusal fikirleri diğerlerinden bir sapmaydı ve reenkarnasyonu açıkça reddediyordu. Bu nedenle, döngüsel yaşam kalıplarını reddeden bir kültür için bir metnin son derece açık olması gerekir ve yukarıdaki belirsiz yorum (özellikle daha belirgin yorum ışığında) basitçe geçerli değildir. Dahası, hem İsa'nın hem de Vaftizci Yahya'nın doğduğu insanlara yazılan İbraniler kitabı reenkarnasyonu açıkça reddeder. Yazarın 9:27'de belirttiği gibi, İnsanın bir kez ölmesi ve ardından yargılanması belirlenmiştir. Burada İsa'nın takipçileri tarafından reenkarnasyonun açıkça reddedildiğini görüyoruz. Bir ölüm vardır. Bir yargılama vardır. Bu nedenle, herhangi bir Hıristiyan dünya görüşünde geri dönmezsiniz.

I see hugely varied performance depending on how many newlines there are in the file I'm visiting. Here's an example. I have two JSON files: ```$ wget https://github.com/Wilfred/ReVo-utilities/blob/a4bdc40dd2656c496defc461fc19c403c8306d9f/revo-export/dictionary.json?raw=true -O one_line.json $ python -m json.tool pretty_printed.json ``` These are two JSON files with the same content. ```one_line.json``` is 18MiB of JSON without any newlines. ```pretty_printed.json``` has newlines and whitespace added, making it 41MiB. However, the bigger file split over many lines is much faster to open in Emacs, both in Javascript mode and Fundamental mode. Why does Emacs have such poor performance with long lines, since it's actually fewer bytes? Is there anything I can do to improve performance without reformatting the data outside of Emacs?

Ziyaret ettiğim dosyada kaç satır sonu olduğuna bağlı olarak büyük ölçüde değişen performans görüyorum. İşte bir örnek. İki JSON dosyam var: ```$ wget https://github.com/Wilfred/ReVo-utilities/blob/a4bdc40dd2656c496defc461fc19c403c8306d9f/revo-export/dictionary.json?raw=true -O one_line.json $ python -m json.tool pretty_printed.json ``` Bunlar aynı içeriğe sahip iki JSON dosyasıdır. ```one_line.json```, satır sonu olmayan 18 MiB JSON'dur. ```pretty_printed.json```, satır sonları ve boşluklar eklenerek 41 MiB yapılmıştır. Ancak, birçok satıra bölünmüş olan daha büyük dosyanın Emacs'te hem Javascript modunda hem de Fundamental modunda açılması çok daha hızlıdır. Emacs, aslında daha az bayt olduğu için uzun satırlarda neden bu kadar kötü performans gösteriyor? Verileri Emacs dışında yeniden biçimlendirmeden performansı artırmak için yapabileceğim bir şey var mı?

Emacs' handling of long lines is not very well optimized. For a number of operations, Emacs has to scan the whole line repeatedly. For example, to display a line, Emacs has to figure out the height of the line, which requires scanning the whole line to find the tallest glyph. Additionally, scanning for bidirectional display eats up a lot of time. You can get some additional information in, for example, the docstring of ```cache-long-line-scans``` (renamed ```cache-long-scans``` in 24.4). You can try and see if setting ```bidi-paragraph-direction``` to ```left-to-right``` and setting ```bidi-inhibit-bpa``` (new in Emacs 27, see footnote 1) to ```t``` improves the speed for you (see footnote 2). This removes some significant contributors to line scans, but sadly not the only ones. The best option is to add newlines. You can pipe a JSON file through e.g. ```python -c 'import json, sys ; json.dump(json.load(sys.stdin), sys.stdout, indent=2)'``` to add newlines and improve readability in general. Footnote 1: ```bidi-inhibit-bpa``` is new in Emacs 27. Setting it to ```t``` can have a noticeable (sometimes dramatic) effect in cases where (a) a physical line is very long, and (b) the line includes many parentheses and/or braces, especially if they are nested. Footnote 2: There is also ```bidi-display-reordering```, but this is only for internal/debugging purposes. Setting it to ```nil``` may improve performance, however that is an unsupported setting which may cause other problems, so it is not recommended. In Emacs 27, the combination of setting ```bidi-paragraph-direction``` and ```bidi-inhibit-bpa``` is a supported configuration which provides approximately the same performance boost.

Emacs'in uzun satırları işleyişi pek iyi optimize edilmemiştir. Emacs, bir dizi işlem için tüm satırı tekrar tekrar taramalıdır. Örneğin, bir satırı görüntülemek için Emacs, satırın yüksekliğini bulmak zorundadır ve bu da en uzun glifi bulmak için tüm satırı taramayı gerektirir. Ek olarak, iki yönlü görüntüleme için tarama çok fazla zaman alır. Örneğin, ```cache-long-line-scans```'ın (24.4'te ```cache-long-scans``` olarak yeniden adlandırıldı) doküman dizgisinde bazı ek bilgiler alabilirsiniz. ```bidi-paragraph-direction```'ı ```left-to-right``` olarak ayarlayıp ```bidi-inhibit-bpa```'yı (Emacs 27'de yeni, dipnot 1'e bakın) ```t``` olarak ayarlayarak hızda iyileşme olup olmadığını deneyip görebilirsiniz (dipnot 2'ye bakın). Bu, satır taramalarına önemli ölçüde katkıda bulunan bazı öğeleri kaldırır, ancak ne yazık ki tek öğeler bunlar değildir. En iyi seçenek yeni satır eklemektir. Örneğin, bir JSON dosyasını ```python -c 'import json, sys ; json.dump(json.load(sys.stdin), sys.stdout, indent=2)'``` üzerinden yönlendirerek yeni satırlar ekleyebilir ve genel olarak okunabilirliği artırabilirsiniz. Dipnot 1: ```bidi-inhibit-bpa```, Emacs 27'de yeni bir özelliktir. Bunu ```t``` olarak ayarlamak, (a) fiziksel bir satırın çok uzun olduğu ve (b) satırın özellikle iç içe geçmiş çok sayıda parantez ve/veya süslü parantez içerdiği durumlarda gözle görülür (bazen dramatik) bir etkiye sahip olabilir. Dipnot 2: ```bidi-display-reordering``` de vardır, ancak bu yalnızca dahili/hata ayıklama amaçlıdır. Bunu ```nil``` olarak ayarlamak performansı artırabilir, ancak bu desteklenmeyen bir ayardır ve başka sorunlara neden olabilir, bu nedenle önerilmez. Emacs 27'de ```bidi-paragraph-direction``` ve ```bidi-inhibit-bpa```'yı ayarlama birleşiminin yaklaşık olarak aynı performans artışını sağlayan desteklenen bir yapılandırma olduğunu unutmayın.

Sooner or later we come across a task in our project, with which we are totally unfamiliar ('we' as in PM, but also possibly the staff assigned to do this particular task). How can we estimate amount of time/work/resources needed to complete such a task? What margins of error should we assume?

Er ya da geç, projemizde tamamen yabancı olduğumuz bir görevle karşılaşırız ('biz' PM olarak, ancak aynı zamanda bu özel görevi yapmakla görevli personel de olabilir). Böyle bir görevi tamamlamak için gereken zaman/iş/kaynak miktarını nasıl tahmin edebiliriz? Hangi hata paylarını varsaymalıyız?

Don't place too much confidence on your first guess just because you've used a sophisticated formula to derive your estimate. Do your best, move on, plan to revise your estimate, don't let bad estimates linger and destroy the discipline of your project schedule ... errors in time estimates are likely to be lognormally distributed... use a method that incorporates an optimistic guess, a pessimistic guess and heavily weights your best guess. Estimate, test, check, then revise and update your project schedule. The third or fourth revision of the estimates is usually about as accurate as you can hope for; your second estimate is far better than your first guess ... if possible, try to get a measure from an early trial of a similar or analogous task ... revise the estimate and revise your plan as soon as better data becomes available. If your first estimate was too conservative, don't allow slack time to corrupt completion of succeeding tasks. If your first estimate was overly optimistic, make your adjustments EARLY and let your stakeholders and customers know. It's more important to be good at following up, to check your estimates and to competently communicate updates than it is to be a develop skill as an estimator of unfamiliar tasks.

Sadece tahmininizi türetmek için karmaşık bir formül kullandığınız için ilk tahmininiz konusunda fazla güvenmeyin. Elinizden gelenin en iyisini yapın, devam edin, tahmininizi gözden geçirmeyi planlayın, kötü tahminlerin kalmasına ve proje programınızın disiplinini bozmasına izin vermeyin... zaman tahminlerindeki hataların lognormal dağılım gösterme olasılığı yüksektir... iyimser bir tahmin, kötümser bir tahmin içeren ve en iyi tahmininizi büyük ölçüde ağırlıklandıran bir yöntem kullanın. Tahmin edin, test edin, kontrol edin, ardından proje programınızı gözden geçirin ve güncelleyin. Tahminlerin üçüncü veya dördüncü gözden geçirilmesi genellikle umduğunuz kadar doğrudur; ikinci tahmininiz ilk tahmininizden çok daha iyidir... mümkünse, benzer veya analoji bir görevin erken bir denemesinden bir ölçüm almaya çalışın... daha iyi veriler mevcut olur olmaz tahmini ve planınızı gözden geçirin. İlk tahmininiz çok muhafazakarsa, boş zamanın sonraki görevlerin tamamlanmasını bozmasına izin vermeyin. İlk tahmininiz aşırı iyimserse, ayarlamalarınızı ERKEN yapın ve paydaşlarınıza ve müşterilerinize bildirin. Bir tahminci olarak yabancı görevleri tahmin etme becerisi geliştirmekten ziyade, takip etmede iyi olmak, tahminlerinizi kontrol etmek ve güncellemeleri yetkin bir şekilde iletmek daha önemlidir.

Why is Nazi-Germany commonly referred to as "The Third Reich" in English? Why is reich not translated when Dritten ("third") is? And what is the English synonym of reich? Realm? Austria (Republik Österreich), Norway (Kongeriket Norge) and Sweden (Konungariket Sverige) all have reich (or the Norwegian/Swedish corresponding etymology related word) in their name and they all have English translations of their name.

Nazi Almanyası neden İngilizce'de genellikle "Üçüncü Reich" olarak anılır? Dritten ("üçüncü") tercüme edilirken reich neden tercüme edilmez? Ve reich'ın İngilizce eş anlamlısı nedir? Realm? Avusturya (Republik Österreich), Norveç (Kongeriket Norge) ve İsveç'in (Konungariket Sverige) hepsinin adında reich (veya Norveççe/İsveççe karşılık gelen etimolojik ilişkili kelime) vardır ve hepsinin adlarının İngilizce çevirileri vardır.

Although English historians have defined Reich as being a strictly German concept of sovereign rule, in the German language itself it means "Empire". In English, we speak of the Holy Roman Empire; in German, it is the HRR or "Heiliges Römisches Reich Deutscher Nation". Wiktionary quotes Busching, who in 1762 explained Reich as a German understanding of "Eminence", from the Latin Regnum, rather than an Empire or a Realm as other cultures would understand it. One could see it as a word used in English, Russian, Portuguese and many other languages as a designation for any kind of German kingdom, empire or absolutism, similar to how one would address a foreigner according to their origin, e.g. Senor Martinez, Monsieur Aragon. Compare it to how many cultures, including the Germans, also use the word "Commonwealth" or "Soviet Union", despite the fact that Bavaria had formed its own Union of Soviets, the Räterepublik, during the Weimar Republic. If you're interested in knowing when the word "Third Reich" came into usage, it is worth noting that during Fascist Germany, the country's official name was Das Deutsche Reich, and in the USA and UK it was usually referred to as Germany, Hitler's Germany, Berlin, Reich or, the most popular term, Nazi Germany. (Sources: Neville Chamberlain's declaration of war against Germany, headlines about Germany in newspapers like the NY Times or the Times, the Daily Mail's Lord Rothermere) In Germany itself, the idea of a third Reich stemmed from the 19th century, where it was a popular philosophical theme in literature and theology. Writers like Johannes Schlaf, who wrote "Das Dritte Reich" in 1899, or the German translator of Ibsen's "The Emperor and the Galilean", popularized the idea of the imminent arrival of a thousand years of Christianity (a kind of positive apocalypse), which would follow a third "Reich". And they would quote Paul the Apostle and various saints, to make it clear that the third Reich would follow the heretic lex naturalis and the lex mosaica. Nazi propagandists exploited this in their articles, making it sound as if the saints had had some sort of epiphany about Hitler and the Nazis. In other words, the Third Reich began as an abstract idea of a Christian revolution, but was assumed by Nazi writers in order to bolster Hitler's popularity and justify the drastic and bloody decisions that the Fascist government was making. In one of the earliest examples of the Third Reich being mentioned outside of Germany, Major Strasser in the film Casablanca talks about the Third Reich as if it was just the beginning to a kind of paradisaical future or of a fourth Reich. After 1945, the term was used exclusively to associate only to the unsuccessful reign of Fascism in Germany, and it ceased as a philosophical or theological idea in German literary circles.

İngiliz tarihçiler Reich'ı kesinlikle Almanca bir egemenlik kuralı olarak tanımlasalar da, Almancada "İmparatorluk" anlamına gelir. İngilizcede Kutsal Roma İmparatorluğu'ndan bahsederiz; Almancada ise HRR veya "Heiliges Römisches Reich Deutscher Nation" olarak geçer. Wiktionary, 1762'de Reich'ı diğer kültürlerin anlayacağı gibi bir İmparatorluk veya Krallık yerine Latince Regnum'dan gelen Almanca bir "Eminlik" anlayışı olarak açıklayan Busching'den alıntı yapar. İngilizce, Rusça, Portekizce ve diğer birçok dilde bir yabancıya kökenine göre hitap edildiği gibi, Alman krallığı, imparatorluğu veya mutlakiyetçiliği belirtmek için kullanılan bir kelime olarak görülebilir, örneğin Senor Martinez, Monsieur Aragon. Almanlar da dahil olmak üzere birçok kültürün, Weimar Cumhuriyeti sırasında Bavyera'nın kendi Sovyetler Birliği'ni, Räterepublik'i kurmuş olmasına rağmen "Commonwealth" veya "Sovyetler Birliği" kelimesini nasıl kullandığıyla karşılaştırın. "Üçüncü Reich" kelimesinin ne zaman kullanılmaya başlandığını merak ediyorsanız, Faşist Almanya döneminde ülkenin resmi adının Das Deutsche Reich olduğunu ve ABD ve İngiltere'de genellikle Almanya, Hitler'in Almanya'sı, Berlin, Reich veya en popüler terim olan Nazi Almanyası olarak anıldığını belirtmekte fayda var. (Kaynaklar: Neville Chamberlain'in Almanya'ya savaş ilanı, NY Times veya Times gibi gazetelerde Almanya hakkındaki manşetler, Daily Mail'den Lord Rothermere) Almanya'da üçüncü bir Reich fikri, 19. yüzyılda edebiyat ve teolojide popüler bir felsefi tema olduğu 19. yüzyıldan kaynaklanmaktadır. 1899'da "Das Dritte Reich"i yazan Johannes Schlaf veya Ibsen'in "İmparator ve Galileli" adlı eserinin Almanca tercümanı gibi yazarlar, üçüncü bir "Reich"i takip edecek olan bin yıllık Hıristiyanlığın (bir tür olumlu kıyamet) yaklaşan gelişini popüler hale getirdiler. Ve üçüncü Reich'ın sapkın lex naturalis ve lex mosaica'yı takip edeceğini açıklığa kavuşturmak için Havari Pavlus'u ve çeşitli azizleri alıntıladılar. Nazi propagandacıları bunu makalelerinde kullanarak azizlerin Hitler ve Naziler hakkında bir tür epifani yaşadıkları izlenimini uyandırdı. Başka bir deyişle, Üçüncü Reich, Hıristiyan bir devrim fikri olarak başladı, ancak Nazi yazarlar tarafından Hitler'in popülaritesini artırmak ve Faşist hükümetin aldığı sert ve kanlı kararları haklı çıkarmak için kullanıldı. Üçüncü Reich'ın Almanya dışında bahsedildiği en eski örneklerden birinde, Casablanca filmindeki Binbaşı Strasser, Üçüncü Reich'tan cennet gibi bir geleceğin veya dördüncü bir Reich'ın başlangıcıymış gibi bahseder. 1945'ten sonra bu terim yalnızca Almanya'daki başarısız Faşizm dönemiyle ilişkilendirilmek için kullanıldı ve Alman edebiyat çevrelerinde felsefi veya teolojik bir fikir olmaktan çıktı.

If we fold a paper and then apply pressure on the newly formed crease, it seems that the paper's surface gets a permanent deformation but what exactly has happened to the paper at a molecular scale?

Bir kağıdı katlayıp yeni oluşan kıvrıma baskı uygularsak, kağıdın yüzeyinin kalıcı bir deformasyona uğradığı görülür ancak moleküler ölçekte kağıda tam olarak ne olmuştur?

Basically, a fold or crease in paper will remain because the structure of the fibers in the paper have become irreversibly damaged. This happens because the paper is bent/compressed beyond its elastic limit. Chemically, paper is mainly composed of cellulose from plant fibers. Cellulose is an organic polymer, which has D-glucose units connected through hydrogen bonds. These bonds form between the oxygen atom of the one-hydroxyl group belonging to the glucose and the hydrogen atom of the next glucose unit. These are microscopic properties of paper, but to understand what happens when we fold paper or do Origami, it is sufficient to learn what is happening macroscopically. All materials have what is called an elastic limit and a plastic region. The elastic limit is the point at which a material will bend but still return to its original position without any permanent change or damage to its structure. Further deforming the material beyond this limit takes it to its plastic region. At this point any structural or physical changes become permanent and the paper will not return to its original form. Every material has a different elastic limit or yield, and plastic region. Imagine holding a piece of paper slightly bent but not folding or creasing it. The plant fibers that make up the paper will not have exceeded their elastic limit. So as soon as you let go of the paper sheet it will quickly return to its noncreased original flat state. However, if you were to roll that piece of paper into a cylinder and hold it for a few minutes, some of these fibers will be pushed beyond the elastic limit which is evident since it will not lie flat anymore since slight deformations have occurred in this sheet. Now, when you properly fold a piece of paper as you would during Origami, the plant fibers along the crease are pushed into the plastic region of the paper, causing a fracture point at the actual line of the fold. A practical example of this is if you were to fold a piece of paper, you will note that if you stretch the paper evenly on both sides of the fold, the paper will tear right on the fold (a quick way to &quot;cut&quot; paper if you have no scissors). The fold then becomes an irreversible structural failure and the fibers in the paper will never regain their original state. Because of this damage to its structure, the paper will from then on have this fold. And no matter how hard you try to flatten out the fold it will never return to its original state. This is why Origami models continually retain their shape.

Temelde, kağıttaki bir katlama veya kıvrım, kağıttaki liflerin yapısı geri dönüşü olmayan bir şekilde hasar gördüğü için kalır. Bunun nedeni, kağıdın elastik sınırının ötesinde bükülmesi/sıkıştırılmasıdır. Kimyasal olarak kağıt, esas olarak bitki liflerinden selülozdan oluşur. Selüloz, hidrojen bağları ile bağlanmış D-glikoz birimlerine sahip organik bir polimerdir. Bu bağlar, glikoza ait bir hidroksil grubunun oksijen atomu ile bir sonraki glikoz biriminin hidrojen atomu arasında oluşur. Bunlar kağıdın mikroskobik özellikleridir, ancak kağıdı katladığımızda veya Origami yaptığımızda ne olduğunu anlamak için makroskopik olarak neler olduğunu öğrenmek yeterlidir. Tüm malzemelerin elastik sınır ve plastik bölge olarak adlandırılan bir özelliği vardır. Elastik sınır, bir malzemenin büküleceği ancak yapısında kalıcı bir değişiklik veya hasar olmadan orijinal konumuna geri döneceği noktadır. Malzemeyi bu sınırın ötesinde daha fazla deforme etmek onu plastik bölgesine götürür. Bu noktada herhangi bir yapısal veya fiziksel değişiklik kalıcı hale gelir ve kağıt orijinal şekline dönmez. Her malzemenin farklı bir elastik sınırı veya verimi ve plastik bölgesi vardır. Bir parça kağıdı hafifçe bükülü ancak katlanmamış veya kırışmamış halde tuttuğunuzu düşünün. Kağıdı oluşturan bitki lifleri elastik sınırlarını aşmamış olacaktır. Bu nedenle, kağıt sayfasını bıraktığınız anda hızla kırışmamış orijinal düz durumuna geri dönecektir. Ancak, o kağıt parçasını bir silindire yuvarlayıp birkaç dakika tutarsanız, bu liflerin bir kısmı elastik sınırın ötesine itilecektir ve bu, artık düz durmayacağından belli olacaktır çünkü bu sayfada hafif deformasyonlar meydana gelmiştir. Şimdi, Origami sırasında yaptığınız gibi bir kağıt parçasını düzgün bir şekilde katladığınızda, kıvrım boyunca bitki lifleri kağıdın plastik bölgesine itilir ve kıvrımın gerçek çizgisinde bir kırılma noktası oluşur. Bunun pratik bir örneği, bir kağıt parçasını katlarsanız, kağıdın her iki tarafını da eşit şekilde gererseniz, kağıdın tam katlama yerinden yırtılacağını göreceksiniz (makasınız yoksa kağıdı "kesmenin" hızlı bir yolu). Katlama daha sonra geri dönüşü olmayan bir yapısal arızaya dönüşür ve kağıttaki lifler asla orijinal durumlarına geri dönmez. Yapısındaki bu hasar nedeniyle, kağıt o zamandan sonra bu katlamaya sahip olacaktır. Ve katlamayı düzeltmek için ne kadar uğraşırsanız uğraşın, asla orijinal durumuna dönmeyecektir. Origami modellerinin şekillerini sürekli olarak korumalarının nedeni budur.

In general, there are two types of syntax of defining functions - Something like C, C++, C#, or Java (```int functionName(char arg)```) vs the ML (and others) tradition of defining the return type after the function (and using something like a ```fun``` keyword to define a function - like ```fun functionName(char arg): int```). One of the advantages (for the parser, at least) for a ```fun``` keyword is that it lets the parser be context-free (it doesn't have to guess if ```int``` defines a variable or if it defines a function). When C was invented, computers had very little memory and speed (so little, that the reason C requires one to define all the variables in the beginning of the function was because it had to be a one-pass parser). Why didn't they choose the simple way out and use function defining keyword?

Genel olarak, fonksiyonları tanımlamanın iki tür söz dizimi vardır - C, C++, C# veya Java gibi bir şey (```int functionName(char arg)```) veya ML'nin (ve diğerlerinin) fonksiyonu tanımlama geleneği (ve bir fonksiyonu tanımlamak için ```fun``` anahtar kelimesi gibi bir şey kullanma - ```fun functionName(char arg): int``` gibi). Bir ```fun``` anahtar kelimesinin avantajlarından biri (en azından ayrıştırıcı için), ayrıştırıcının bağlamsız olmasına izin vermesidir (```int```'in bir değişken mi yoksa bir fonksiyon mu tanımladığını tahmin etmek zorunda değildir). C icat edildiğinde, bilgisayarların çok az belleği ve hızı vardı (o kadar az ki, C'nin fonksiyonun başında tüm değişkenleri tanımlamasının nedeni, tek geçişli bir ayrıştırıcı olması gerektiğiydi). Neden basit yolu seçmediler ve fonksiyon tanımlama anahtar kelimesini kullanmadılar?

Dennis Ritchie’s paper on The Development of the C Language gives some idea of the reasoning behind this: namely, the fundamental rule in C that declaration syntax should match expression syntax" For each object of such a composed type, there was already a way to mention the underlying object: index the array, call the function, use the indirection operator on the pointer. Analogical reasoning led to a declaration syntax for names mirroring that of the expression syntax in which the names typically appear. Thus, ```int i, *pi, **ppi; ``` declare an integer, a pointer to an integer, a pointer to a pointer to an integer. The syntax of these declarations reflects the observation that ```i```, ```*pi```, and ```**ppi``` all yield an ```int``` type when used in an expression. Similarly, ```int f(), *f(), (*f)(); ``` declare a function returning an integer, a function returning a pointer to an integer, a pointer to a function returning an integer; ```int *api[10], (*pai)[10]; ``` declare an array of pointers to integers, and a pointer to an array of integers. In all these cases the declaration of a variable resembles its usage in an expression whose type is the one named at the head of the declaration. It appears this rule trumped parser considerations. Its immediate consequence is that function declarations can’t use specific keywords, or impose a different ordering of declaration components. It’s worth noting that parsing was somewhat different in early C, since function declarations didn’t specify their arguments, and function definitions separated the argument list from the argument declarations (which weren’t necessary for ```int``` arguments): ```sum(); ``` declares a ```sum``` function, which would then be defined as ```sum(a, b) { return a + b; } ``` (no types needed here, the default is ```int```). So the parser didn’t deal with types inside argument lists.

Dennis Ritchie'nin C Dilinin Gelişimi hakkındaki makalesi bunun ardındaki mantığa dair fikir veriyor: yani, C'deki temel kural, bildirim söz diziminin ifade söz dizimiyle eşleşmesi gerektiğidir" Böyle bileşik bir türün her nesnesi için, altta yatan nesneden bahsetmenin zaten bir yolu vardı: diziyi indeksle, işlevi çağır, işaretçi üzerindeki dolaylılık işlemini kullan. Analojik akıl yürütme, adların tipik olarak göründüğü ifade söz dizimini yansıtan adlar için bir bildirim söz dizimine yol açtı. Böylece, ```int i, *pi, **ppi; ``` bir tamsayı, bir tamsayıya işaret eden bir işaretçi, bir tamsayıya işaret eden bir işaretçiye işaret eden bir işaretçi bildirir. Bu bildirimlerin söz dizimi, ```i```, ```*pi``` ve ```**ppi```'nin tümünün bir ifadede kullanıldığında ```int``` türü verdiğini gösteren gözlemi yansıtır. Benzer şekilde, ```int f(), *f(), (*f)(); ``` bir tamsayı döndüren bir işlev, bir tamsayıya işaret eden bir işaretçi döndüren bir işlev, bir tamsayı döndüren bir işlevi işaret eden bir işaretçi bildirir; ```int *api[10], (*pai)[10]; ``` tamsayılara işaret eden işaretçilerden oluşan bir dizi ve tamsayı dizisine işaret eden bir işaretçi bildirir. Tüm bu durumlarda, bir değişkenin bildirimi, bildirimin başında adlandırılan türde bir ifadedeki kullanımına benzer. Görünüşe göre bu kural ayrıştırıcı hususlarını alt etti. Bunun doğrudan sonucu, işlev bildirimlerinin belirli anahtar sözcükleri kullanamayacağı veya bildirim bileşenlerinin farklı bir sıralamasını dayatamayacağıdır. İşlev bildirimleri argümanlarını belirtmediğinden ve işlev tanımları argüman listesini argüman bildirimlerinden ayırdığından (```int``` argümanları için gerekli olmayan): ```sum(); ``` erken C'de ayrıştırmanın biraz farklı olduğuna dikkat etmek gerekir. ```sum``` işlevini bildirir ve bu daha sonra şu şekilde tanımlanır: ```sum(a, b) { return a + b; } ``` (burada türlere gerek yoktur, varsayılan ```int```'tir). Bu nedenle ayrıştırıcı, argüman listelerinin içindeki türlerle ilgilenmedi.

I am new to TeX, working on it for about 2 months. Have not yet figured out how to script the 'curvy L' for Lagrangian and/or for Laplace Transforms. As of now I am using the 'L' - which is not good! :-( Any help? UPDATE The 2 best solutions are; ```\usepackage{ amssymb } \mathcal{L} ``` and ```\usepackage{ mathrsfs } \mathscr{L} ``` I got my answers at, http://detexify.kirelabs.org/classify.html

TeX'e yeniyim, yaklaşık 2 aydır üzerinde çalışıyorum. Lagrangian ve/veya Laplace Dönüşümleri için 'kıvrımlı L'yi nasıl yazacağımı henüz çözemedim. Şu anda 'L'yi kullanıyorum - bu iyi değil! :-( Yardımcı olur musunuz? GÜNCELLEME En iyi 2 çözüm; ```\usepackage{ amssymb } \mathcal{L} ``` ve ```\usepackage{ mathrsfs } \mathscr{L} ``` Cevaplarımı http://detexify.kirelabs.org/classify.html adresinden aldım

You have been told how to get a curved L. But here's some more general advice, which also applies in this situation: In cases such as this, always create your own shortcut macro, say ```\newcommand{\Lagr}{\mathcal{L}} ``` This way, if you ever decide that that curly L is not quite the one you like, it is easy to switch. Also, even before you knew the answer to this question, you could have written ```\newcommand{\Lagr}{L} ``` in your preamble. Then you could start/continue writing the document, use ordinary capital Ls where you want, and ```\Lagr``` wherever you actually mean a Lagrangian, and then later changing the definition of ```\Lagr``` to something appropriate. This way, you wouldn't have to manually search for each occurence of a capital L and decide if it's a Lagrangian or not. Clearly ```\Lagr``` (or whatever you want to call this macro) is also easier to type than ```\mathcal{L}```, and it makes the source code much more readable. Another advantage, which is probably more subtle, since you're new to LaTeX, is that we can make the curvy L exactly the type of math we want. TeX distinguishes between ordinary letters, binary operators, binary relations, opening and closing parenthesis and so on; the spacing between two ordinary letters is not the same as the spacing between the ```a```, ```+```, and ```b``` in ```$a+b$```. So since the Lagrangian is a kind of operator, we could say ```\newcommand{\Lagr}{\mathop{\mathcal{L}}} ``` But in the case of operators, the package amsmath (which you are most likely using; if not, you should) provides a somewhat better mechanism: ```\DeclareMathOperator{\Lagr}{\mathcal{L}} ``` Another (related) tip: Even if you are using the same notation for two different things, it is best to make a separate macro for each. In this case you might have ```\DeclareMathOperator{\Lagr}{\mathcal{L}} \DeclareMathOperator{\Lapl}{\mathcal{L}} ``` The reason is the same as in the ```L``` vs. ```\Lagr``` case above: If you at some point decide that using ```\mathcal{L}``` for both is a bad idea, you would have to find each occurence of ```\Lagr``` and figure out if it is really a Laplacian. Using macro names carrying semantic meaning is one of the great powers of TeX.

Kavisli L'nin nasıl elde edileceği size anlatıldı. Ancak işte bu durumda da geçerli olan daha genel bazı tavsiyeler: Bu gibi durumlarda, her zaman kendi kısayol makronuzu oluşturun, örneğin ```\newcommand{\Lagr}{\mathcal{L}} ``` Bu şekilde, bu kıvrımlı L'nin tam olarak istediğiniz gibi olmadığına karar verirseniz, geçiş yapmak kolaydır. Ayrıca, bu sorunun cevabını bilmeden önce bile önsözünüze ```\newcommand{\Lagr}{L} ``` yazmış olabilirsiniz. Ardından belgeyi yazmaya başlayabilir/devam edebilir, istediğiniz yerde sıradan büyük harf L'leri kullanabilir ve aslında bir Lagranj anlamına geldiği her yerde ```\Lagr``` kullanabilir ve daha sonra ```\Lagr``` tanımını uygun bir şeye değiştirebilirsiniz. Bu şekilde, büyük harf L'nin her bir oluşumunu manuel olarak aramanız ve Lagranj olup olmadığına karar vermeniz gerekmez. Açıkça ```\Lagr``` (veya bu makroya ne ad vermek isterseniz) ```\mathcal{L}```'den yazması daha kolaydır ve kaynak kodunu çok daha okunaklı hale getirir. LaTeX'te yeni olduğunuz için muhtemelen daha incelikli olan bir başka avantaj, kıvrımlı L'yi tam olarak istediğimiz matematik türü yapabilmemizdir. TeX, sıradan harfler, ikili işlemler, ikili ilişkiler, açılış ve kapanış parantezleri vb. arasında ayrım yapar; iki sıradan harf arasındaki boşluk, ```$a+b$``` içindeki ```a```, ```+``` ve ```b``` arasındaki boşlukla aynı değildir. Bu nedenle, Lagranj bir tür operatör olduğundan, şunu söyleyebiliriz ```\newcommand{\Lagr}{\mathop{\mathcal{L}}} ``` Ancak operatörler durumunda, amsmath paketi (büyük olasılıkla kullandığınız; değilse, kullanmalısınız) biraz daha iyi bir mekanizma sağlar: ```\DeclareMathOperator{\Lagr}{\mathcal{L}} ``` Bir başka (ilgili) ipucu: İki farklı şey için aynı gösterimi kullanıyor olsanız bile, her biri için ayrı bir makro yapmak en iyisidir. Bu durumda şuna sahip olabilirsiniz ```\DeclareMathOperator{\Lagr}{\mathcal{L}} \DeclareMathOperator{\Lapl}{\mathcal{L}} ``` Nedeni, yukarıdaki ```L``` ile ```\Lagr``` durumuyla aynıdır: Bir noktada her ikisi için de ```\mathcal{L}``` kullanmanın kötü bir fikir olduğuna karar verirseniz, ```\Lagr```'ın her bir oluşumunu bulmanız ve bunun gerçekten bir Laplasyen olup olmadığını anlamanız gerekir. Anlamsal anlam taşıyan makro adları kullanmak, TeX'in en büyük güçlerinden biridir.

My son doesn't want to share anything with other kids, and if some kid even so much as touches his toy, he pushes the kid. He shouts and cries at the same time, and tries to express his anger by pushing and hitting the kid. I feel so embarrassed in front of other parents. And when he is at home with me and doing something wrong, I try to stop him, he tries to repeat my words and shouts at me. He is copying the behavior of others, whether it's a good act or bad... Please help me how to stop him from being a bully.

Oğlum diğer çocuklarla hiçbir şeyini paylaşmak istemiyor ve bir çocuk oyuncağına dokunursa bile çocuğu itiyor. Aynı anda bağırıyor ve ağlıyor ve öfkesini çocuğu iterek ve vurarak ifade etmeye çalışıyor. Diğer ebeveynlerin önünde çok utanıyorum. Ve evde benimle birlikteyken ve yanlış bir şey yaparken onu durdurmaya çalıştığımda, sözümü tekrar etmeye çalışıyor ve bana bağırıyor. İster iyi ister kötü olsun, başkalarının davranışlarını kopyalıyor... Lütfen bana onun zorba olmasını nasıl engelleyeceğim konusunda yardım edin.

Welcome to the "Terrible Two's"! Your son behaves typically for his age. At 2 he starts to assert himself and express his demands. It's likely that he has also learned that he gets his way when he throws a tantrum. For a 2-year old screaming, hitting or even biting is a normal way to express his anger - at least he will try and every success reinforces this. He also comes across more limitations: The more he is able to do, the more often he is stopped. The solution? It's already in your question: He will copy what others do. So by all means, stay calm. No yelling, no fussing and - please! - no hitting. He has some learning (accepted behaviour like sharing) and some unlearning (no hitting or pushing) to do and needs your help. * When he throws a tantrum, either ignore him, or quietly remove him from the scene. Do not worry about others! Most likely they have had the same trouble with their kids or will some time ;-) * When he doesn't want to share yet - fine, he will learn. This can be practiced. Don't make him share, or he will resent it. Rather, teach him the benefits of sharing. Start with food, for example. Have a plate of cookies (or other favorite food), that's yours. He will likely demand some, but demanding doesn't get him a cookie. Asking nicely will! Explain, repeat. Then, switch roles. If he has cookies, ask him to share. If he does, praise him. Else - remind him next time when he wants your cookies that he didn't share. Share whenever possible: Having a bite from your plate, getting a piece off his. Repeat, repeat, repeat.... Same goes for objects. Ask him to "please" share a toy, "play" with it for a short moment, then return. Say "Thank you". He learns, that he gets the toy back. Share some of your things. (Monitor the behaviour of other children, that want his toys - make sure they ask first and give toys back, at least during this learning stage.) You have some serious work to do, but it will be sooooo worth it!

"Korkunç İkili"ye hoş geldiniz! Oğlunuz yaşı için tipik davranışlar sergiliyor. 2 yaşında kendini ifade etmeye ve taleplerini dile getirmeye başlar. Bir öfke nöbeti geçirdiğinde istediğini elde ettiğini de öğrenmiş olması muhtemeldir. 2 yaşındaki bir çocuk için çığlık atmak, vurmak hatta ısırmak öfkesini ifade etmenin normal bir yoludur - en azından deneyecektir ve her başarı bunu pekiştirir. Ayrıca daha fazla sınırlamayla karşılaşır: Ne kadar çok şey yapabilirse, o kadar sık durdurulur. Çözüm? Zaten sorunuzda var: Başkalarının yaptıklarını kopyalayacaktır. Bu yüzden sakin kalmaya çalışın. Bağırmayın, telaş yapmayın ve - lütfen! - vurmayın. Öğrenmesi gereken bazı şeyler (paylaşmak gibi kabul edilebilir davranışlar) ve öğrenmemesi gereken bazı şeyler (vurmak veya itmek gibi) vardır ve sizin yardımınıza ihtiyacı vardır. * Bir öfke nöbeti geçirdiğinde, onu ya görmezden gelin ya da sessizce oradan uzaklaştırın. Başkalarını düşünmeyin! Büyük ihtimalle onlar da çocuklarıyla aynı sıkıntıyı yaşamışlardır veya yaşayacaklardır ;-) * Henüz paylaşmak istemiyorsa - sorun değil, öğrenecektir. Bu pratik yapılabilir. Onu paylaşmaya zorlamayın, yoksa içerleyecektir. Bunun yerine, ona paylaşmanın faydalarını öğretin. Örneğin yiyeceklerle başlayın. Sizin olan bir tabak kurabiye (veya başka bir favori yiyecek) olsun. Muhtemelen biraz isteyecektir, ancak talep etmek ona kurabiye kazandırmaz. Nazikçe sormak kazandıracaktır! Açıklayın, tekrarlayın. Sonra rolleri değiştirin. Eğer onun kurabiyeleri varsa, paylaşmasını isteyin. Paylaşırsa, onu övün. Aksi takdirde - bir dahaki sefere sizin kurabiyelerinizi istediğinde paylaşmadığını hatırlatın. Mümkün olduğunca paylaşın: Tabaktanızdan bir ısırık alın, onunkinden bir parça alın. Tekrarlayın, tekrarlayın, tekrarlayın... Aynı şey nesneler için de geçerlidir. Bir oyuncağı "lütfen" paylaşmasını isteyin, kısa bir süre "oynayın", sonra geri verin. "Teşekkür ederim" deyin. Oyuncağı geri aldığını öğrenir. Eşyalarınızdan bazılarını paylaşın. (Oyuncaklarını isteyen diğer çocukların davranışlarını izleyin - en azından bu öğrenme aşamasında önce sorduklarından ve oyuncakları geri verdiklerinden emin olun.) Yapmanız gereken ciddi bir iş var, ancak buna değecek!

What are the differences between the Strategy design pattern and the State design pattern? please explain the difference in layman's terms?

Strateji tasarım deseni ile Durum tasarım deseni arasındaki farklar nelerdir? Lütfen farkı basit bir dille açıklar mısınız?

The difference simply lies in that they solve different problems: * The State pattern deals with what (state or type) an object is (in) -- it encapsulates state-dependent behavior, whereas * the Strategy pattern deals with how an object performs a certain task -- it encapsulates an algorithm. The constructs for achieving these different goals are however very similar; both patterns are examples of composition with delegation. Some observations on their advantages: * By using the State pattern the state-holding (context) class is relieved from knowledge of what state or type it is and what states or types that are available. This means that the class adheres to the open-closed design principle (OCP): the class is closed for changes in what states/types there are, but the states/types are open to extensions. * By using the Strategy pattern the algorithm-using (context) class is relieved from knowledge of how to perform a certain task (-- the "algorithm"). This case also creates an adherence to the OCP; the class is closed for changes regarding how to perform this task, but the design is very open to additions of other algorithms for solving this task. This likely also improves the context class' adherence to the single responsibility principle (SRP). Further the algorithm becomes easily available for reuse by other classes.

Fark, basitçe farklı sorunları çözmelerinde yatar: * Durum kalıbı, bir nesnenin ne (durum veya tür) olduğunu (içinde) ele alır -- durum bağımlı davranışı kapsülerken, * Strateji kalıbı, bir nesnenin belirli bir görevi nasıl gerçekleştirdiğini ele alır -- bir algoritmayı kapsüler. Ancak bu farklı hedeflere ulaşmak için kullanılan yapılar oldukça benzerdir; her iki kalıp da devretme ile bileşimin örnekleridir. Avantajları hakkında bazı gözlemler: * Durum kalıbını kullanarak, durumu tutan (bağlam) sınıfı, hangi durumda veya türde olduğu ve hangi durumların veya türlerin mevcut olduğu bilgisinden kurtulur. Bu, sınıfın açık-kapalı tasarım ilkesine (OCP) bağlı olduğu anlamına gelir: sınıf, hangi durumların/türlerin olduğu konusundaki değişikliklere kapalıdır, ancak durumlar/türler uzantılara açıktır. * Strateji kalıbını kullanarak, algoritmayı kullanan (bağlam) sınıfı, belirli bir görevi nasıl gerçekleştireceği ("algoritma") bilgisinden kurtulur. Bu durum da OCP'ye bağlılık yaratır; sınıf, bu görevi nasıl gerçekleştireceğiyle ilgili değişikliklere kapalıdır, ancak tasarım, bu görevi çözmek için başka algoritmaların eklenmesine çok açıktır. Bu, muhtemelen bağlam sınıfının tek sorumluluk ilkesine (SRP) bağlılığını da geliştirir. Ayrıca algoritma, diğer sınıflar tarafından yeniden kullanılmak üzere kolayca kullanılabilir hale gelir.

Why don't Tour de France riders always ride their TT bikes?

Tour de France bisikletçileri neden her zaman TT bisikletlerini kullanmazlar?

There are 2 good reasons for this. First, a TT bike is the most efficient machine for flat, fast course racing, where there are a minimum of hills. It is not the most efficient machine when it comes to climbing. The body position is far too aggressive for even professional athletes to use in a non-TT style event. A bike with more a more upright body position, a more stable weight distribution, a lighter frame, and far, far lighter wheels, is a more efficient choice for that style of ride. Secondly, a TT bike sacrifices bike handling for that extreme power and aero efficiency. The TT stages are controlled events, where there are either one rider, or one team on the course at a time, and so limitations on stability and handling are acceptable. Take the same bike in a 150 rider peloton, where riders constantly jockey for position, and where even on a stable bike losing focus for 1 second can cause a major crash, and all of a sudden, those same sacrifices in bike handling and stability are no longer a benefit for the rider or the team. They become a hazard to the team's chances of winning. And not just for the stage or the day, since a bad crash can take a rider out for the season. Or God forbid, permanently. For these reasons, the UCI has seen fit to ban the bikes in non-TT events, in order to ensure rider safety. And for once, their decision makes sense.

Bunun için 2 iyi neden var. Birincisi, TT bisikleti, minimum düzeyde yokuşun olduğu düz, hızlı parkur yarışları için en verimli makinedir. Tırmanma söz konusu olduğunda en verimli makine değildir. Vücut pozisyonu, profesyonel sporcuların bile TT tarzı olmayan bir etkinlikte kullanması için fazlasıyla agresiftir. Daha dik bir vücut pozisyonuna, daha dengeli bir ağırlık dağılımına, daha hafif bir kadroya ve çok daha hafif tekerleklere sahip bir bisiklet, bu sürüş tarzı için daha verimli bir seçimdir. İkincisi, bir TT bisikleti, o aşırı güç ve aerodinamik verimlilik için bisiklet kullanımından ödün verir. TT etapları, bir seferde parkurda bir sürücü veya bir takımın bulunduğu kontrollü etkinliklerdir ve bu nedenle denge ve kullanım üzerindeki sınırlamalar kabul edilebilir. Aynı bisikleti, sürücülerin sürekli olarak pozisyon için mücadele ettiği ve dengeli bir bisiklette bile 1 saniyeliğine odaklanmayı kaybetmenin büyük bir kazaya neden olabileceği 150 sürücülük bir pelotonda kullanın ve birdenbire bisiklet kullanımındaki ve dengedeki aynı fedakarlıklar sürücü veya takım için artık bir avantaj olmaktan çıkar. Takımın kazanma şansları için bir tehlike haline gelirler. Ve sadece etap veya gün için değil, çünkü kötü bir kaza bir sürücüyü sezon boyunca devre dışı bırakabilir. Ya da Allah korusun, kalıcı olarak. Bu nedenlerden dolayı UCI, sürücü güvenliğini sağlamak için TT dışı etkinliklerde bisikletleri yasaklamayı uygun görmüştür. Ve bu kez, kararları mantıklı.

I remember when the Muslim holy book was the Koran when I was in middle school, but now it's the Quran. But it's always been Qatar and Iraq (but still Kuwait.) Who decided that 'Q' was going to be represent that sound instead of 'K', and why?

Ortaokuldayken Müslümanların kutsal kitabının Kuran olduğunu hatırlıyorum ama şimdi Kur'an. Ama Katar ve Irak hep öyleydi (ama Kuveyt hala öyle.) 'Q' harfinin 'K' yerine o sesi temsil edeceğine kim karar verdi ve neden?

In Arabic, in fact, they've always been separate sounds! The sound we write "K" is spelled with the letter ك in Arabic, and is pronounced a little bit further forward in the mouth; the sound we write "Q" is spelled with the letter ق and pronounced a little bit farther back. In phonetic terms, "K" is a velar sound, and "Q" is a uvular sound. English doesn't distinguish between these two different sounds. But since we've got a spare letter lying around—the English letter "Q" is actually related to the Arabic letter ق, if you go back far enough!—it's become conventional to separate them in writing. "Kuwait" is spelled with a ك, so it gets a "K"; "Qatar" is spelled with a ق, so it gets a "Q". The "Qur'an", similarly, has a ق in it. Nowadays, by the way, the letter "Q" has started to be associated with Arabic in particular, since it shows up significantly more there than in English. So in pop culture, you'll sometimes see names like "Hakeem" respelled to "Haqim"—even though the original Arabic has a ك in it! Linguistically, this is called hypercorrection, and it's the same reason you'll see words like "forté" with an é: English-speakers associate the acute accent with Romance loans (café, fiancé, résumé), but it has no special meaning in English, so it sometimes gets inserted where it doesn't actually belong (the original Italian word is simply forte).

Arapçada aslında bunlar her zaman ayrı sesler olmuştur! "K" olarak yazdığımız ses Arapçada ك harfiyle yazılır ve ağızda biraz daha önde telaffuz edilir; "Q" olarak yazdığımız ses ق harfiyle yazılır ve biraz daha geride telaffuz edilir. Fonetik terimlerle, "K" velar bir sestir ve "Q" uvular bir sestir. İngilizce bu iki farklı ses arasında ayrım yapmaz. Ancak elimizde kullanılmayan bir harf olduğundan -İngilizce "Q" harfi aslında Arapça ق harfiyle ilişkilidir, yeterince geriye giderseniz!- bunları yazarken ayırmak geleneksel hale gelmiştir. "Kuveyt" ك ile yazılır, bu nedenle "K" alır; "Katar" ق ile yazılır, bu nedenle "Q" alır. Benzer şekilde "Kuran"da ق vardır. Bu arada, günümüzde "Q" harfi özellikle Arapça ile ilişkilendirilmeye başlandı, çünkü İngilizceden çok daha fazla orada karşımıza çıkıyor. Bu nedenle popüler kültürde bazen "Hakeem" gibi isimlerin "Haqim" olarak yeniden yazıldığını görürsünüz -orijinal Arapçada ك olmasına rağmen! Dilbilimsel olarak buna aşırı düzeltme denir ve "forté" gibi kelimeleri é ile görmenizin nedeni de budur: İngilizce konuşanlar keskin aksanı Roman dillerinden alınan sözcüklerle ilişkilendirir (café, fiancé, résumé), ancak İngilizcede özel bir anlamı yoktur, bu nedenle bazen ait olmadığı yerlere eklenir (orijinal İtalyanca kelime sadece forte'dir).

How do you add Boost libraries in CMakeLists.txt?

CMakeLists.txt'ye Boost kütüphaneleri nasıl eklenir?

Put this in your `CMakeLists.txt` file (change any options from OFF to ON if you want): ``` set(Boost_USE_STATIC_LIBS OFF) set(Boost_USE_MULTITHREADED ON) set(Boost_USE_STATIC_RUNTIME OFF) find_package(Boost VERSION COMPONENTS *boost libraries here*) if(Boost_FOUND) include_directories(${Boost_INCLUDE_DIRS}) add_executable(progname file1.cxx file2.cxx) target_link_libraries(progname ${Boost_LIBRARIES}) endif() ``` Obviously you need to put the libraries you want where I put `*boost libraries here*`. For example, if you're using the `filesystem` and `regex` library you'd write: ``` find_package(Boost VERSION COMPONENTS filesystem regex) ```

Bunu `CMakeLists.txt` dosyanıza ekleyin (istediğiniz seçenekleri KAPALI'dan AÇIK'a değiştirin): ``` set(Boost_USE_STATIC_LIBS OFF) set(Boost_USE_MULTITHREADED ON) set(Boost_USE_STATIC_RUNTIME OFF) find_package(Boost VERSION COMPONENTS *boost libraries here*) if(Boost_FOUND) include_directories(${Boost_INCLUDE_DIRS}) add_executable(progname file1.cxx file2.cxx) target_link_libraries(progname ${Boost_LIBRARIES}) endif() ``` Açıkçası, `*boost libraries here*` yerine istediğiniz kütüphaneleri koymanız gerekir. Örneğin, `filesystem` ve `regex` kütüphanesini kullanıyorsanız şunu yazarsınız: ``` find_package(Boost VERSION COMPONENTS filesystem regex) ```

Quando devo fazer essa gravação direto no banco? Quais as situações? Eu sei que posso gravar no banco o caminho da imagem.

Bu kaydı doğrudan bankada ne zaman yapmalıyım? Hangi durumlarda? Görüntünün yolunu bankaya kaydedebileceğimi biliyorum.

Além do custo ser mais alto como mencionado, deve-se levar em conta vários fatores: * Volume de dados: para um baixo volume de dados pode não haver problema. Por outro lado, para armazenamento de grande massa de dados o banco de dados é praticamente inviável. Pergunte ao Facebook ou ao Google se eles usariam banco. O Facebook, por exemplo, usa um sistema de arquivos personalizado para tornar o acesso mais rápido ainda e diminuir a o overhead por arquivo exigido pelos sistemas de arquivos tradicionais. * Clusterização: uma vantagem do banco de dados é no caso do seu sistema rodar em vários servidores, todos terão acesso uniforme aos arquivos. Porém, usar uma unidade na rede para armazenar os arquivos. * Disponibilidade: seu sistema vai ter muitos acessos? Isso pode sobrecarregar um banco de dados tradicional. Por outro lado, seu servidor HTTP pode usar as rotinas de acesso de baixo nível ao sistema de arquivos para enviar o stream de dados ao cliente. * Escalabilidade: se a demanda de volume ou disponibilidade aumentarem, será possível adicionar mais capacidade ao sistema? É muito mais fácil dividir arquivos entre servidores diferentes do que distribuir registros de uma tabela em mais servidores. * Flexibilidade: fazer cópias de segurança, mover arquivos de um servidor para outro, fazer algum processamento nos arquivos armazenados, tudo isso fica mais fácil se os arquivos estiverem num diretório. Se você faz o deploy em ambiente de cliente, os arquivos no disco não inviabilizam você de receber cópias do banco de dados para testes. Tente pedir para o seu cliente enviar terabytes de dados para você analisar se der algum problema no banco. * Overhead de leitura e gravação: o custo computacional para gravar e ler dados do banco de dados é maior do que para ler e gravar diretamente em um arquivo. Existem várias estratégias para escalar um sistema tanto em termos de disponibilidade quanto em volume. Basicamente essas estratégias consistem em distribui-los em vários vários servidores e redirecionar o usuário para cada um deles conforme algum critério. Os detalhes variam de implementação, tais como: estratégia de atualização dos dados, redundância, critérios de distribuição, etc. Uma das grandes dificuldades em gerenciar arquivos fora do BD é que temos agora duas fontes de dados distintas e que precisam estar sempre em sincronia. Do ponto de vista de segurança, efetivamente há pouca diferença. Se um hacker pode comprometer um servidor, ele poderá ler tanto os arquivos gravados em disco do seu sistema quanto os arquivos do sistema de banco de dados. Se essa questão for crítica, uma alternativa é armazenar os dados criptografados. Porém, sempre que fiz a análise do melhor tipo de solução, o uso do sistema de arquivos sempre esteve em grande vantagem.

Daha önce de belirtildiği gibi maliyetin daha yüksek olmasının yanı sıra, çeşitli faktörler de dikkate alınmalıdır: * Veri hacmi: düşük veri hacmi için sorun olmayabilir. Öte yandan, büyük veri kümelerinin depolanması için veritabanı pratik olarak uygulanamaz. Facebook veya Google'a veritabanı kullanıp kullanmadıklarını sorun. Örneğin Facebook, erişimi daha da hızlandırmak ve geleneksel dosya sistemlerinin gerektirdiği dosya başına genel giderleri azaltmak için özel bir dosya sistemi kullanır. * Kümeleme: veritabanının bir avantajı, sisteminizin birden fazla sunucuda çalışması durumunda, tümünün dosyalara tekdüzen erişime sahip olmasıdır. Ancak, dosyaları depolamak için ağda bir birim kullanın. * Kullanılabilirlik: sisteminiz çok fazla erişime sahip olacak mı? Bu, geleneksel bir veritabanını aşırı yükleyebilir. Öte yandan, HTTP sunucunuz, veri akışını istemciye göndermek için dosya sistemine düşük düzeyli erişim yordamlarını kullanabilir. * Ölçeklenebilirlik: hacim veya kullanılabilirlik talebi artarsa, sisteme daha fazla kapasite eklemek mümkün olacak mı? Dosyaları farklı sunucular arasında bölmek, bir tablonun kayıtlarını daha fazla sunucuya dağıtmaktan çok daha kolaydır. * Esneklik: yedekleme yapmak, dosyaları bir sunucudan diğerine taşımak, depolanan dosyalarda bazı işlemler yapmak, dosyalar bir dizindeyse tüm bunlar daha kolay hale gelir. Müşteri ortamında dağıtım yapıyorsanız, diskteki dosyalar, test için veritabanı kopyaları almanızı engellemez. Bir sorun çıkması durumunda analiz etmeniz için müşterinizden size terabaytlarca veri göndermesini istemeyi deneyin. * Okuma ve yazma genel gideri: veritabanına veri yazma ve okuma için gereken hesaplama maliyeti, doğrudan bir dosyaya okuma ve yazma maliyetinden daha yüksektir. Bir sistemi hem kullanılabilirlik hem de hacim açısından ölçeklendirmek için çeşitli stratejiler vardır. Temel olarak bu stratejiler, sistemi çeşitli sunuculara dağıtmaktan ve kullanıcıyı belirli bir kritere göre her birine yönlendirmekten oluşur. Ayrıntılar, veri güncelleme stratejisi, yedeklilik, dağıtım kriterleri vb. gibi uygulamadan uygulamaya değişir. BD dışındaki dosyaları yönetmenin en büyük zorluklarından biri, artık sürekli olarak senkronize edilmesi gereken iki farklı veri kaynağımız olmasıdır. Güvenlik açısından bakıldığında, aslında çok az fark vardır. Bir bilgisayar korsanı bir sunucuyu tehlikeye atabilirse, hem sisteminizin diskte kayıtlı dosyalarını hem de veritabanı sisteminin dosyalarını okuyabilir. Bu sorun kritikse, bir alternatif veriyi şifrelenmiş olarak saklamaktır. Ancak, en iyi çözüm türünün analizini her yaptığımda, dosya sisteminin kullanımı her zaman büyük bir avantaja sahip oldu.

I need a regular expression that validates a number, but doesn't require a digit after the decimal. ie. ```123 123. 123.4 ``` would all be valid ```123.. ``` would be invalid

Ondalıklı sayıdan sonra rakam gerektirmeyen ancak bir sayıyı doğrulayan bir düzenli ifadeye ihtiyacım var. Yani ```123 123. 123.4 ``` hepsi geçerli olur ```123.. ``` geçersiz olur

Here is the regular expression you can use: ``` /^\d*\.?\d*$/ ``` * `^` - Beginning of the line; * `\d*` - 0 or more digits; * `\.?` - An optional dot (escaped, because in regex, . is a special character); * `\d*` - 0 or more digits (the decimal part); * `$` - End of the line. This allows for .5 decimal rather than requiring the leading zero, such as 0.5

İşte kullanabileceğiniz düzenli ifade: ``` /^\d*\.?\d*$/ ``` * `^` - Satırın başı; * `\d*` - 0 veya daha fazla rakam; * `\.?` - İsteğe bağlı bir nokta (kaçış karakteri, çünkü regex'te . özel bir karakterdir); * `\d*` - 0 veya daha fazla rakam (ondalık kısım); * `$` - Satırın sonu. Bu, 0,5 gibi önde gelen sıfıra gerek kalmadan .5 ondalık sayısına izin verir

The year is 2109 C.E my friends and I were caught in a space disaster when the spacecraft we're in broke apart during a daring escape from a patrolling spacecraft. We stole an antique cellphone (from 1999, in good working condition) from a space museum but our escape was interrupted and fortunately we managed to get into the escape pod and didn't get caught up in the explosion. The only emergency transponder in the escape pod isn't working probably due to the destruction of the spacecraft. Given the technology of 1999, is it possible for us to sent out a distress signal to alert the leaving patrol spacecraft? Note: the cellphone was the most innovative product of 1999 money can buy. The escape pod is not a Faraday cage we're talking about the future and the patrol spacecraft don't necessary be on a lookout for distress signal; please use these clues to your advantage. If there is absolutely no way to transmit any man-made signal out, please state a valid reason why it can't be done.

Yıl 2109 C.E. Arkadaşlarım ve ben, devriye gezen bir uzay aracından cesurca kaçarken içinde bulunduğumuz uzay aracının parçalanmasıyla bir uzay felaketine yakalandık. Bir uzay müzesinden antika bir cep telefonu (1999'dan, iyi durumda) çaldık ancak kaçışımız yarıda kaldı ve neyse ki kaçış kapsülüne girmeyi başardık ve patlamada yakalanmadık. Kaçış kapsülündeki tek acil durum vericisi, muhtemelen uzay aracının imhası nedeniyle çalışmıyor. 1999 teknolojisi göz önüne alındığında, ayrılan devriye uzay aracını uyarmak için bir yardım sinyali göndermemiz mümkün mü? Not: Cep telefonu, 1999'da para karşılığı satın alınabilecek en yenilikçi üründü. Kaçış kapsülü bir Faraday kafesi değil, gelecekten bahsediyoruz ve devriye uzay aracı mutlaka bir yardım sinyali aramıyor; lütfen bu ipuçlarını kendi yararınıza kullanın. Hiçbir şekilde insan yapımı bir sinyal iletmenin yolu yoksa, neden yapılamayacağına dair geçerli bir neden belirtin.

Assets * 1 obsolete piece of short range comms kit requiring a battery you probably can't charge * 1 slightly malfunctioning escape pod with up to date comms that isn't working but you're still alive Current standards say the Mayday should be broadcast on VHF channel 16 (156.8 MHz). A 1999 phone, probably on 2g would likely use 900MHz (UHF). The slightly broken comms unit in the pod is probably using channel 16 or equivalent*. This is your first problem. The patrol ship will be listening in for signals broadcast on the mayday frequency. That's the frequency you need to hit, so first up is rebuilding your phone to that frequency. Or you could look at the pod comms system and see what's wrong. Your next problem is that your mobile phone's range is laughable in interstellar space. What's going to be even more laughable is when you try to use it in the radiation shielded environment of your escape pod. The signal, which is line of sight at the best of times, most likely won't even penetrate the hull. So now you need to hook it up to the external antenna used by the pod's own comms system. Or you could look at the pod comms system and see what's wrong. Now you need to make sure you're using the right broadcast method: are you on AM or FM? (There's no reason to think that 100 years from now they'd be able to pick up an analog signal) I'm sure you can see where I'm going with this. Fix the pod. Ultimately all you're going to do is rebuild a copy of the pod's own comms system with a batch of obsolete components. If you're good enough to do that you're good enough to fix the pod's own system which will be much easier. *I mention channel 16 as an example to show that there are standards for distress signals and they're very different from the standards for mobiles, if you want someone to pick it up then you need to be broadcasting on a frequency they're listening on. ## Distress frequencies 2182 kHz forms an essential part of the Global Maritime Distress Safety System (GMDSS). It has an associated DSC frequency at 2187.5 kHz. Other international distress frequencies, in use as of 2008, include: ```121.5 MHz - civil aircraft emergency frequency 243 MHz - military aircraft emergency frequency 156.8 MHz - Marine VHF radio channel 16, short range maritime use 406 MHz / 406.1 MHz - Cospas-Sarsat international satellite-based search and rescue (SAR) distress alert detection and information distribution system ``` Discontinued frequencies ```500 kHz Morse code is no longer monitored. 121.5 or 243 MHz locators. (No longer automatically monitored by satellite, though still used for aircraft communication and short-range direction finding.) Effective 1 August 2013, the U. S. Coast Guard terminated its radio guard of the international voice distress, safety and calling frequency 2182 kHz and the international digital selective calling (DSC) distress and safety frequency 2187.5 kHz. Additionally, marine information and weather broadcasts transmitted on 2670 kHz terminated concurrently. ```

Varlıklar * Muhtemelen şarj edemeyeceğiniz bir pile ihtiyaç duyan, kullanılmayan bir kısa menzilli iletişim kiti * Güncel iletişim sistemine sahip, ancak çalışmayan ve hala hayatta olduğunuz hafif arızalı bir kaçış kapsülü Mevcut standartlar, Mayday'in VHF kanal 16'da (156,8 MHz) yayınlanması gerektiğini belirtir. Muhtemelen 2g'de olan 1999 model bir telefon muhtemelen 900MHz (UHF) kullanacaktır. Kapsüldeki hafif arızalı iletişim ünitesi muhtemelen kanal 16 veya eşdeğerini kullanmaktadır*. Bu sizin ilk sorununuz. Devriye gemisi, mayday frekansında yayınlanan sinyalleri dinliyor olacaktır. İhtiyacınız olan frekans budur, bu nedenle önce telefonunuzu bu frekansa göre yeniden yapılandırmanız gerekir. Ya da kapsül iletişim sistemine bakabilir ve sorunun ne olduğunu görebilirsiniz. Bir sonraki sorununuz, cep telefonunuzun menzilinin yıldızlararası uzayda gülünç olmasıdır. Kaçış kapsülünüzün radyasyonla korunan ortamında kullanmaya çalıştığınızda daha da gülünç olacaktır. En iyi zamanlarda görüş hattı olan sinyal, büyük ihtimalle gövdeye bile nüfuz etmeyecektir. Bu nedenle şimdi onu kapsülün kendi iletişim sistemi tarafından kullanılan harici antene bağlamanız gerekir. Ya da kapsül iletişim sistemine bakabilir ve sorunun ne olduğunu görebilirsiniz. Şimdi doğru yayın yöntemini kullandığınızdan emin olmanız gerekir: AM mi yoksa FM mi kullanıyorsunuz? (100 yıl sonra analog bir sinyali alabileceklerini düşünmek için hiçbir neden yok) Bunun nereye gittiğimi görebileceğinizden eminim. Kapsülü onarın. Sonuçta yapacağınız tek şey, kapsülün kendi iletişim sisteminin bir kopyasını bir grup kullanılmayan bileşenle yeniden oluşturmaktır. Bunu yapacak kadar iyiyseniz, kapsülün kendi sistemini onarmak için yeterince iyisinizdir ve bu çok daha kolay olacaktır. *Kanal 16'dan, sıkıntı sinyalleri için standartların olduğunu ve bunların cep telefonları için standartlardan çok farklı olduğunu göstermek için bir örnek olarak bahsediyorum; birinin bunu almasını istiyorsanız, dinledikleri bir frekansta yayın yapmanız gerekir. ## Sıkıntı frekansları 2182 kHz, Küresel Denizcilik Sıkıntı Güvenlik Sistemi'nin (GMDSS) önemli bir parçasıdır. 2187,5 kHz'de ilişkili bir DSC frekansına sahiptir. 2008 itibarıyla kullanımda olan diğer uluslararası sıkıntı frekansları şunlardır: ``` 121,5 MHz - sivil uçak acil durum frekansı 243 MHz - askeri uçak acil durum frekansı 156,8 MHz - Deniz VHF radyo kanalı 16, kısa menzilli deniz kullanımı 406 MHz / 406,1 MHz - Cospas-Sarsat uluslararası uydu tabanlı arama ve kurtarma (SAR) sıkıntı uyarısı algılama ve bilgi dağıtım sistemi ``` Kullanılmayan frekanslar ``` 500 kHz Mors kodu artık izlenmiyor. 121,5 veya 243 MHz konum belirleyiciler. (Artık uydu tarafından otomatik olarak izlenmiyor, ancak yine de uçak iletişimi ve kısa menzilli yön bulma için kullanılıyor.) 1 Ağustos 2013'ten itibaren ABD Sahil Güvenlik, uluslararası sesli sıkıntı, güvenlik ve çağrı frekansı 2182 kHz ve uluslararası dijital seçici çağrı (DSC) sıkıntı ve güvenlik frekansı 2187,5 kHz'deki radyo nöbetini sonlandırdı. Ayrıca, 2670 kHz'de iletilen deniz bilgileri ve hava durumu yayınları eş zamanlı olarak sonlandırıldı. ```

Often I want to just point the camera to an object or a specific area in my scene to get an idea of how it'll look in the render. What's the most painless hassle-free way to do this in blender? A quick search on the blender wiki does not lend itself to easy look-up due to all the noise in the search result. This question could probably be broken down into these two main questions: * How do I point a selected camera to the current 3d-cursor location in the scene? * How do I point the selected camera to the currently selected object(s) in the scene?

Genellikle sahnemdeki bir nesneye veya belirli bir alana kamerayı doğrultarak renderda nasıl görüneceğine dair bir fikir edinmek isterim. Blender'da bunu yapmanın en zahmetsiz ve sorunsuz yolu nedir? Blender wiki'de hızlı bir arama, arama sonucundaki tüm gürültü nedeniyle kolay bir aramaya izin vermiyor. Bu soru muhtemelen şu iki ana soruya ayrılabilir: * Seçili kamerayı sahnedeki geçerli 3 boyutlu imleç konumuna nasıl yönlendiririm? * Seçili kamerayı sahnedeki geçerli seçili nesne(ler)e nasıl yönlendiririm?

Situation 1: You're not looking through the camera yet * Fly Mode: Shift + F or the standard Viewport Navigation * Set Camera to View: Ctrl + Alt + Numpad 0 Situation 2: You're already looking through the camera via Numpad 0 * Select the camera: Right Mouse Button * Grab: G & optionally... * Lock the grab to a local axis: XX or YY or ZZ (my favorite) * Rotate: * Tilt: R * Look around: R R * Orbit around the 3D cursor: .R followed by R, or Z. (Press , afterwards) Tips & Notes (some go beyond this question): 1. In earlier versions of Blender, Fly Mode would to make the camera slowly flatten with the horizon line. It doesn't anymore, but you can reset the camera's rotation Alt + R to make the horizon flat and then use fly mode to reorient the camera while maintaining that flat horizon. 2. If you decide to use another object as a target for the camera to look at, you can use the Object Constraints. To do this: * Select the camera. * Shift-select the target. * Press Ctrl T and select Track To or Damped Track To. You can modify the new constraint in the camera's Constraints panel, for example, to animate the influence.

Durum 1: Henüz kameradan bakmıyorsunuz * Uçuş Modu: Shift + F veya standart Görüntü Alanı Navigasyonu * Kamerayı Görüntülemeye Ayarla: Ctrl + Alt + Sayısal Tuş Takımı 0 Durum 2: Sayısal Tuş Takımı 0 ile kameradan bakıyorsunuz * Kamerayı seçin: Sağ Fare Düğmesi * Tut: G ve isteğe bağlı olarak... * Tutmayı yerel bir eksene kilitle: XX veya YY veya ZZ (benim favorim) * Döndür: * Eğim: R * Etrafa bak: R R * 3B imlecin etrafında yörünge: .R ardından R veya Z. (Sonrasında , tuşuna basın) İpuçları ve Notlar (bazıları bu sorunun ötesine geçer): 1. Blender'ın önceki sürümlerinde Uçuş Modu, kameranın ufuk çizgisiyle yavaşça düzleşmesine neden olurdu. Artık yapmıyor, ancak kameranın dönüşünü sıfırlamak için Alt + R tuşlarına basarak ufku düzleştirebilir ve ardından kamerayı düz ufku korurken yeniden yönlendirmek için uçuş modunu kullanabilirsiniz. 2. Kameranın bakması için başka bir nesneyi hedef olarak kullanmaya karar verirseniz, Nesne Kısıtlamalarını kullanabilirsiniz. Bunu yapmak için: * Kamerayı seçin. * Hedefi Shift tuşunu basılı tutarak seçin. * Ctrl T tuşuna basın ve İzle veya Sönümlü İzle'yi seçin. Yeni kısıtlamayı, örneğin etkiyi canlandırmak için kameranın Kısıtlamalar panelinde değiştirebilirsiniz.

What are the general tactics of Krav Maga as opposed to Systema? For instance, the tactics of Silat are to hurt the other person so badly they can't hurt back. Another example would be that the tactics of boxing would be to knock out the other person first using only punches. So, as far as I know, the goal of Systema and Krav Maga are both to do anything you can to defeat your attacker because they are serious about self defense. Does that mean that Krav Maga and Systema are strategical identical? Does Krav use strategies that Systema doesn't? Does Systema use any strategies that Krav doesn't? Is there a difference or do they generally work the same way?

Krav Maga'nın Systema'ya karşı genel taktikleri nelerdir? Örneğin, Silat'ın taktikleri diğer kişiyi o kadar kötü yaralamaktır ki geri saldıramaz. Bir başka örnek ise boks taktiklerinin sadece yumruklar kullanarak diğer kişiyi nakavt etmek olmasıdır. Yani bildiğim kadarıyla Systema ve Krav Maga'nın amacı, kendilerini savunma konusunda ciddi oldukları için saldırganlarını yenmek için ellerinden gelen her şeyi yapmaktır. Bu, Krav Maga ve Systema'nın stratejik olarak aynı olduğu anlamına mı geliyor? Krav, Systema'nın kullanmadığı stratejiler kullanıyor mu? Systema, Krav'ın kullanmadığı stratejiler kullanıyor mu? Bir fark var mı yoksa genel olarak aynı şekilde mi çalışıyorlar?

At first glance Krav Maga and Systema seem to be very similar in that they are both very unconventional, no-rules, practical self-defence, martial arts (although Krav isn't technically a martial art) which are no holds barred and generally formless. However... Krav Maga is basically a very raw, dangerous situation survival system (including avoidance and escape) which builds upon your natural instincts and taught in a very short space of time. Therefore it is highly stress tested. It relies on the fact that fear will set in in order to use your natural responses and turn them into functional movements to your advantage. It relies heavily on shock and awe in that defence and attack should be simultaneous where possible to capitalise on the opponent's shock value. Systema is - in many ways - the exact opposite, it is a system which teaches over a much longer period of time how to control your fear/anger/pity and teaches relaxation (through breathing/stretching) in stressful situations so that attacks on your person are less effective, better recovered from and the pressure points, levers and momentum of attackers can be manipulated to your advantage using the clarity of mind gained from your training. In Summary So in effect Krav Maga is taught fast and turns your weaknesses into strengths so your defence/attack becomes like a reflex just when you need it, while Systema is a methodology that needs to be learned and seeks to remove those weaknesses so that your defense/attacks can be more effective. Also, another martial art, similar and somewhere between these is the Keysi Fighting Method (KFM) - developed for street fighting - but that has some actual forms that have to be learned such as the very distinctive 'Pensador' that the Christian Bale Batman uses/ KFM is a lot more like Krav Maga but it makes heavy use of the 'Pensador' guard (much like the 'Rhino' Krav pose) and concentrates a much larger chunk of its time to dealing with multiple opponents and ground based fighting, as it was developed for street fighting and this is where they tend to end up. It doesn't deal with survival (avoidance and get away) as much as Krav however. There are also no weapons.

İlk bakışta Krav Maga ve Systema, her ikisi de çok alışılmadık, kuralsız, pratik kendini savunma, dövüş sanatları (Krav teknik olarak bir dövüş sanatı olmasa da) olması bakımından çok benzer görünmektedir (genellikle sınırsız ve biçimsizdir). Ancak... Krav Maga temelde doğal içgüdüleriniz üzerine inşa edilmiş ve çok kısa bir sürede öğretilen çok ham, tehlikeli bir durumdan kurtulma sistemidir (kaçınma ve kurtulma dahil). Bu nedenle oldukça streslidir. Doğal tepkilerinizi kullanmak ve bunları kendi avantajınıza işlevsel hareketlere dönüştürmek için korkunun devreye gireceği gerçeğine dayanır. Mümkün olduğunda savunma ve saldırının eşzamanlı olması gerektiği için şok ve dehşete büyük ölçüde dayanır ve böylece rakibin şok değerinden yararlanılır. Systema -birçok açıdan- tam tersidir, çok daha uzun bir süre boyunca korkunuzu/öfkenizi/acımanızı kontrol etmeyi öğreten ve stresli durumlarda gevşemeyi (nefes alma/gerinme yoluyla) öğreten bir sistemdir, böylece kişiye yönelik saldırılar daha az etkili olur, daha iyi kurtulunur ve saldırganların baskı noktaları, kaldıraçları ve momentumu, eğitimden kazanılan zihinsel berraklık kullanılarak kendi avantajınıza manipüle edilebilir. Özetle Yani aslında Krav Maga hızlı öğretilir ve zayıflıklarınızı güçlü yönlere dönüştürür, böylece savunmanız/saldırınız tam da ihtiyacınız olduğunda bir refleks haline gelirken, Systema öğrenilmesi gereken ve savunma/saldırılarınızın daha etkili olabilmesi için bu zayıflıkları gidermeyi amaçlayan bir metodolojidir. Ayrıca, benzer ve bu ikisinin arasında bir yerde olan bir başka dövüş sanatı da sokak dövüşü için geliştirilen Keysi Dövüş Yöntemi'dir (KFM) - ancak Christian Bale Batman'in kullandığı çok belirgin 'Pensador' gibi öğrenilmesi gereken bazı gerçek biçimleri vardır. KFM, Krav Maga'ya çok daha benzer, ancak 'Pensador' korumasını (tıpkı 'Rhino' Krav pozu gibi) yoğun bir şekilde kullanır ve zamanının çok daha büyük bir kısmını birden fazla rakiple başa çıkmaya ve sokak dövüşü için geliştirildiği için genellikle sona erdikleri yer olan yerde dövüşmeye ayırır. Ancak Krav kadar hayatta kalma (kaçınma ve kurtulma) ile ilgilenmez. Ayrıca silah da yoktur.

I understand that unlocking the bootloader will wipe my Android phone, but have been looking around for why. Seems to be by design, but what is the reasoning for that design? Is it some security concern, some obscure technical reason, or just for lulz? I'm looking for something solid to chew on here, something more than because "that's how it is".

Android telefonumun kilidini açmanın onu sileceğini anlıyorum, ancak nedenini araştırıyordum. Tasarım gereği gibi görünüyor, ancak bu tasarımın gerekçesi nedir? Güvenlik endişesi mi, belirsiz teknik bir neden mi yoksa sadece eğlence için mi? "Çünkü böyle"den daha fazlası, burada üzerinde kafa yorabileceğim sağlam bir şey arıyorum.

It's a security concern. The Android documentation doesn't provide a lot of elaboration, stating simply: The procedure must be confirmed on-screen, and deletes the user data for privacy reasons. However, the privacy concern is relatively straightforward to extrapolate. Once the bootloader is unlocked, the device can be flashed with unsigned images. This means that it is relatively trivial to root the device, and there are actually multiple ways it can be done, such as: * Flashing a system image with root tools built in * Flashing a boot image that runs ```adbd``` with root by default (an "unsecure" image) * Flashing a recovery image, then using that to overwrite the system or boot partitions with ones that allow root access Once root is obtained, all of the information on ```/data``` essentially becomes accessible. This could be emails, contact information, or many other pieces of personal information that you likely don't want in the wrong hands. Therefore, it makes sense to wipe all of this data during the unlocking procedure to ensure that there is no off-the-shelf "official" way of bypassing the sandboxing restrictions implemented by the Android operating system, which would thereby allow someone to steal personal data. Of course, there may be ways to root without wiping on some devices, but they rely on exploits rather than official methods like a bootloader unlock, meaning they are basically bugs.

Bu bir güvenlik endişesidir. Android belgeleri fazla ayrıntı vermez ve sadece şunları belirtir: Prosedür ekranda onaylanmalıdır ve gizlilik nedenleriyle kullanıcı verilerini siler. Ancak gizlilik endişesi nispeten basit bir şekilde çıkarılabilir. Önyükleyici kilidi açıldıktan sonra, cihaz imzasız görüntülerle flaşlanabilir. Bu, cihazı rootlamanın nispeten önemsiz olduğu anlamına gelir ve bunu yapmanın aslında birden fazla yolu vardır, örneğin: * Kök araçları yerleşik olarak bulunan bir sistem görüntüsünü flaşlama * Varsayılan olarak ```adbd```'yi kök olarak çalıştıran bir önyükleme görüntüsü flaşlama ("güvenli olmayan" bir görüntü) * Bir kurtarma görüntüsü flaşlama, ardından bunu kök erişimine izin veren sistem veya önyükleme bölümlerinin üzerine yazmak için kullanma Kök elde edildikten sonra, ```/data``` üzerindeki tüm bilgiler esasen erişilebilir hale gelir. Bu, e-postalar, iletişim bilgileri veya muhtemelen yanlış ellere geçmesini istemediğiniz diğer birçok kişisel bilgi olabilir. Bu nedenle, Android işletim sistemi tarafından uygulanan sandbox kısıtlamalarını atlamanın standart bir "resmi" yolu olmadığından emin olmak için kilit açma prosedürü sırasında tüm bu verileri silmek mantıklıdır, bu da birinin kişisel verileri çalmasına olanak tanır. Elbette, bazı cihazlarda silmeden rootlama yolları olabilir, ancak bunlar önyükleyici kilidi açma gibi resmi yöntemlerden ziyade istismarlara dayanır, yani temelde hatalardır.

The original IBM PC and later variants used an Intel 8253 or 8254 as a sound chip. Why did users add sound cards such as the Adlib or Sound Blaster. I remember voice output with programs like telephone answering programs. The sound was wimpy but I attributed most of the quality to speaker size. What was lacking with the original PC sound chip?

Orijinal IBM PC ve sonraki varyantları ses çipi olarak Intel 8253 veya 8254 kullandı. Kullanıcılar neden Adlib veya Sound Blaster gibi ses kartları ekledi? Telefon yanıtlama programları gibi programlarla ses çıkışını hatırlıyorum. Ses zayıftı ama kalitenin çoğunu hoparlör boyutuna bağladım. Orijinal PC ses çipinde ne eksikti?

> The original IBM PC and later variants used an Intel 8253 or 8254 as a sound chip. The 8253 is a timer circuit, containing three timers able to generate timed interrupts or square-wave output with programmed frequencies. On the PC the third timer's output is, via an amplifier, connected to a simple speaker. As said before, calling a 'simple' timer a sound chip is quite a stretch. Since it's a digital output, no level control is available. Only on or off is possible. At best this results in rather nasty sounding square waves. There is no provision to smooth the signal (beside the inertia of the speaker membrane). Also, the only frequencies that can be selected are those that result from dividing the base frequency (1,193,181.8 Hz) by an integer in the range of 1&ndash;65535. So even when accepting the meager signal quality, only very few notes can be played at correct frequency. Already the basic 440 Hz concert pitch will be off by .5Hz. So whatever is played using the timer will sound off pitch. Music can still sound good if a little off pitch, but only when all notes are off in the same way (*1) - which is not the case with this 'sound chip'. Of course, there are also ways to manipulate the sound even a bit better by manually handling the output - which results in 100% CPU time usage. > Why did users add sound cards such as the Adlib or Sound Blaster. Simply because they wanted sound - or at least music. Not just a beeper. > What was lacking with the original PC sound chip? As said before, it's no sound chip at all. A sound chip will need programmable oscillators for different wave forms and at least some analogue ciruitry to make a smooth, more natural sound. Ofcourse, from an enginering point, the PC's use of a timer was a great improvement over the Apple II, its model and competition, as it allowed the beeping in parallel - not that this feature was used by BIOS or DOS. Last but not least, the PC is an open system. It is made to add new/better hardware. So why shoudn't there be a real sound card? Improving the machine is a core feature of the design. Addendum: agtoever added a comment with a great example of what was possible with the direct fiddling with the speaker. Awesome, but less than apealing when compared to even the cheapest form of soundcard, the AdLib of the same time, as used by Monkey Island. Next to zero CPU usage and crisp clear sound. Not to mention easy programming. I'd call that a huge advantage. *1 - The average human decodes frequencies relative to each other. As a result sound is still perceived as good, even if the whole scale is shifted, as long as it's in the same direction and same percentage. Output needs to be way off to be noticed by an average listener. In contrast, if notes are off by a different margin and in different directions, even less trained listeners will notice.

> Orijinal IBM PC ve sonraki varyantlar ses çipi olarak Intel 8253 veya 8254 kullandı. 8253, zamanlanmış kesintiler veya programlanmış frekanslarla kare dalga çıkışı üretebilen üç zamanlayıcı içeren bir zamanlayıcı devresidir. PC'de üçüncü zamanlayıcının çıkışı, bir amplifikatör aracılığıyla basit bir hoparlöre bağlanır. Daha önce de söylendiği gibi, "basit" bir zamanlayıcıyı ses çipi olarak adlandırmak biraz abartılıdır. Dijital bir çıkış olduğu için seviye kontrolü mevcut değildir. Sadece açık veya kapalı mümkündür. En iyi ihtimalle bu, oldukça kötü ses veren kare dalgalarla sonuçlanır. Sinyalin yumuşatılması için bir hüküm yoktur (hoparlör diyaframının ataletinin yanı sıra). Ayrıca, seçilebilen tek frekanslar, temel frekansı (1.193.181,8 Hz) 1-65535 aralığındaki bir tam sayıya bölerek elde edilenlerdir. Bu nedenle, yetersiz sinyal kalitesini kabul etseniz bile, doğru frekansta yalnızca çok az nota çalınabilir. Temel 440 Hz konser perdesi bile 0,5 Hz ile kapanacaktır. Yani zamanlayıcıyı kullanarak çalınan her şey perde dışı gelecektir. Müzik, biraz perde dışı olsa bile yine de iyi gelebilir, ancak yalnızca tüm notalar aynı şekilde perde dışı olduğunda (*1) - bu da bu "ses çipi" için geçerli değildir. Elbette, çıkışı manuel olarak işleyerek sesi biraz daha iyi manipüle etmenin yolları da vardır - bu da %100 CPU zamanı kullanımına neden olur. > Kullanıcılar neden Adlib veya Sound Blaster gibi ses kartları ekledi? Sadece ses istedikleri için - veya en azından müzik. Sadece bir bip sesi değil. > Orijinal PC ses çipinde ne eksikti? Daha önce de söylendiği gibi, bu hiç de bir ses çipi değil. Bir ses çipinin, farklı dalga biçimleri için programlanabilir osilatörlere ve pürüzsüz, daha doğal bir ses çıkarmak için en azından bazı analog devrelere ihtiyacı olacaktır. Elbette, bir mühendislik açısından, PC'nin bir zamanlayıcı kullanması, modeli ve rakibi olan Apple II'ye göre büyük bir gelişmeydi, çünkü bip sesinin paralel olarak çalınmasına izin veriyordu - bu özelliğin BIOS veya DOS tarafından kullanılmaması. Son olarak, PC açık bir sistemdir. Yeni/daha iyi donanım eklemek için yapılmıştır. Öyleyse neden gerçek bir ses kartı olmasın? Makineyi geliştirmek, tasarımın temel bir özelliğidir. Ek: agtoever, hoparlörle doğrudan oynamanın mümkün olduğuna dair harika bir örnek içeren bir yorum ekledi. Harika, ancak aynı zamanda Monkey Island tarafından kullanılan AdLib gibi en ucuz ses kartı türüyle karşılaştırıldığında daha az çekici. Sıfıra yakın CPU kullanımı ve net, berrak ses. Kolay programlamadan bahsetmiyorum bile. Buna büyük bir avantaj derim. *1 - Ortalama bir insan frekansları birbirine göre çözer. Sonuç olarak, tüm ölçek aynı yönde ve aynı yüzde kaydırıldığı sürece, ses hala iyi olarak algılanır. Ortalama bir dinleyici tarafından fark edilmesi için çıktının çok fazla olması gerekir. Buna karşılık, notalar farklı bir farkla ve farklı yönlerde perde dışıysa, daha az eğitimli dinleyiciler bile fark edecektir.

According to the sources I have found, a lambda expression is essentially implemented by the compiler creating a class with overloaded function call operator and the referenced variables as members. This suggests that the size of lambda expressions varies, and given enough references variables that size can be arbitrarily large. An ```std::function``` should have a fixed size, but it must be able to wrap any kind of callables, including any lambdas of the same kind. How is it implemented? If ```std::function``` internally uses a pointer to its target, then what happens, when the ```std::function``` instance is copied or moved? Are there any heap allocations involved?

Bulduğum kaynaklara göre, bir lambda ifadesi esasen derleyici tarafından aşırı yüklenmiş fonksiyon çağrı operatörü ve üye olarak referans alınan değişkenler ile bir sınıf oluşturarak uygulanır. Bu, lambda ifadelerinin boyutunun değiştiğini ve yeterince referans değişkeni verildiğinde bu boyutun keyfi olarak büyük olabileceğini gösterir. Bir ```std::function``` sabit bir boyuta sahip olmalıdır, ancak aynı türden herhangi bir lambda dahil olmak üzere her türlü çağrılabilir öğeyi sarabilmelidir. Nasıl uygulanır? ```std::function``` dahili olarak hedefini gösteren bir işaretçi kullanıyorsa, ```std::function``` örneği kopyalandığında veya taşındığında ne olur? Yığın tahsisleri var mı?

The implementation of ```std::function``` can differ from one implementation to another, but the core idea is that it uses type-erasure. While there are multiple ways of doing it, you can imagine a trivial (not optimal) solution could be like this (simplified for the specific case of ```std::function<int (double)>``` for the sake of simplicity): ```struct callable_base { virtual int operator()(double d) = 0; virtual ~callable_base() {} }; template <typename F> struct callable : callable_base { F functor; callable(F functor) : functor(functor) {} virtual int operator()(double d) { return functor(d); } }; class function_int_double { std::unique_ptr<callable_base> c; public: template <typename F> function(F f) { c.reset(new callable<F>(f)); } int operator()(double d) { return c(d); } // ... }; ``` In this simple approach the ```function``` object would store just a ```unique_ptr``` to a base type. For each different functor used with the ```function```, a new type derived from the base is created and an object of that type instantiated dynamically. The ```std::function``` object is always of the same size and will allocate space as needed for the different functors in the heap. In real life there are different optimizations that provide performance advantages but would complicate the answer. The type could use small object optimizations, the dynamic dispatch can be replaced by a free-function pointer that takes the functor as argument to avoid one level of indirection, but the idea is basically the same. Regarding the issue of how copies of the ```std::function``` behave, a quick test indicates that copies of the internal callable object are done, rather than sharing the state. ```// g++4.8 int main() { int value = 5; typedef std::function<void()> fun; fun f1 = [=]() mutable { std::cout << value++ << '\n' }; fun f2 = f1; f1(); // prints 5 fun f3 = f1; f2(); // prints 5 f3(); // prints 6 (copy after first increment) } ``` The test indicates that ```f2``` gets a copy of the callable entity, rather than a reference. If the callable entity was shared by the different ```std::function<>``` objects, the output of the program would have been 5, 6, 7.

```std::function``` uygulaması bir uygulamadan diğerine farklılık gösterebilir ancak temel fikir tür silme kullanmasıdır. Bunu yapmanın birden fazla yolu olsa da, basit (en iyi olmayan) bir çözümün şu şekilde olabileceğini düşünebilirsiniz (sadelik adına ```std::function<int (double)>``` özel durumu için basitleştirilmiştir): ```struct callable_base { virtual int operator()(double d) = 0; virtual ~callable_base() {} }; template <typename F> struct callable : callable_base { F functor; callable(F functor) : functor(functor) {} virtual int operator()(double d) { return functor(d); } }; class function_int_double { std::unique_ptr<callable_base> c; public: template <typename F> function(F f) { c.reset(new callable<F>(f)); } int operator()(double d) { return c(d); } // ... }; ``` Bu basit yaklaşımda ```function``` nesnesi yalnızca bir temel türe ```unique_ptr``` depolar. ```function``` ile kullanılan her farklı fonksiyon için, temel türeden türetilen yeni bir tür oluşturulur ve bu türden bir nesne dinamik olarak örneklenir. ```std::function``` nesnesi her zaman aynı boyutta olur ve yığında farklı fonksiyonlar için gerektiği kadar alan ayırır. Gerçek hayatta performans avantajları sağlayan ancak cevabı karmaşıklaştıracak farklı optimizasyonlar vardır. Tür, küçük nesne optimizasyonlarını kullanabilir, dinamik dağıtım, fonksiyonu dolaylılık düzeyini önlemek için argüman olarak alan serbest fonksiyon işaretçisiyle değiştirilebilir ancak fikir temelde aynıdır. ```std::function``` kopyalarının nasıl davrandığı konusuna gelince, hızlı bir test, durumun paylaşılması yerine dahili çağrılabilir nesnenin kopyalarının yapıldığını gösterir. ```// g++4.8 int main() { int value = 5; typedef std::function<void()> fun; fun f1 = [=]() mutable { std::cout << value++ << '\n' }; fun f2 = f1; f1(); // 5 yazdırır fun f3 = f1; f2(); // 5 yazdırır f3(); // 6 yazdırır (ilk artıştan sonra kopya) } ``` Test, ```f2```'nin bir referans yerine çağrılabilir varlığın bir kopyasını aldığını gösterir. Çağrılabilir varlık farklı ```std::function<>``` nesneleri tarafından paylaşılsaydı, programın çıktısı 5, 6, 7 olurdu.

So, I'm on vacation in Utah, and so I attended an LDS service. In the morning, I heard a reading from one of the Presidents of the church during the "Quorum of the Elders," then went to Sunday School, and finally witnessed the Sacrement of the bread and water. (I guess it makes sense there was no wine, but it did make me go "Huh!") After that, there were testimonies from missionaries and some music - but nothing that struck me as a sermon. Was I missing something, or was this an atypical service? I guess I was trying to understand what the "pastor"s role in the service was supposed to be - or again, is it just that Mormons are even more Baptist than baptists? If someone could explain how instruction and exhortation are primarily conferred in the LDS church Id appreciate it.

Yani, Utah'ta tatildeyim ve bir LDS ayinine katıldım. Sabah, "Yaşlılar Toplantısı" sırasında kilise başkanlarından birinin okuduğu bir metni dinledim, sonra Pazar Okuluna gittim ve son olarak ekmek ve suyun kutsanmasına tanık oldum. (Sanırım şarap olmaması mantıklıydı ama yine de "Ha!" dedirdi.) Bundan sonra, misyonerlerden tanıklıklar ve biraz müzik vardı - ama vaaz olarak algıladığım hiçbir şey yoktu. Bir şey mi kaçırdım yoksa bu alışılmadık bir ayin miydi? Sanırım "papaz"ın ayindeki rolünün ne olması gerektiğini anlamaya çalışıyordum - ya da yine, Mormonlar Baptistlerden bile daha mı Baptist? Biri LDS kilisesinde talimat ve öğüdün nasıl verildiğini açıklayabilirse sevinirim.

Mormon services are a bit different, as you discovered. In the United States, there is generally a block of 3 meetings back-to-back including a sunday school, a mens' and women's time for instruction, and a sacrament meeting where the general congregation meets together. It sounds like the first meeting you attended was Priesthood meeting where the brothers study the words of scripture and modern Church leaders. Those classes usually have a single instructor each week. Sacrament meeting is where any equivalence of a sermon would be heard. The primary difference between Mormon services and some others is the focal event of church meetings. The purpose behind holding a sacrament meeting is to take the sacrament and renew covenants made at baptism. The actual administration of the sacrament is the most sacred public meeting to Mormons. Hearing people speak and even interpersonal communion (socializing) is only secondary, though important. Members of a ward, or local congregation, are invited to speak by the bishop or his counselors (the basic equivalent of a pastor) and will have some time to prepare a talk. Talks should draw from the scriptures, personal experience and testimony, and focus on the Savior. Note that comments made by church members over the pulpit at a sacrament meeting do not necessarily reflect the Church's official position on a topic or even Church doctrine. The talks are meant to urge, inspire, and exhort all in attendance to come to Christ, to give them an opportunity to feel the power of the Spirit, and to strengthen their faith. Often, members will come with questions in their hearts and find answers in the words that day. Counsel from leaders like a bishop sometimes occur over the pulpit, but usually this is private and individual, based on personal circumstances. The bishop and his counselors are supposed to meet with members regularly in interviews. There is no paid clergy, so all the service is volunteer. Each member is also assigned two "home teachers" which visit their family once a month to share a gospel message, check on well-being, and be a friend and support especially when needed. In this way, instruction is given which might also help replace a typical sermon pattern. The bishop, his counselors, and others he calls on help organize these efforts. (It has also proven to be very quick and effective during disaster response, as home teachers immediately report in on who they teach, and bishops coordinate an effort if needed. So what you saw was apparently quite normal. Even once a month (the first Sunday), a fast and testimony meeting is held during sacrament meeting, where members forgo preparing talks and instead bear their testimonies about Christ and the gospel for the hour as they feel a desire to do so. Instruction is very member-to-member, you might say, but is guided by the direction of a bishop and other church leaders who also inspire and instruct.

Mormon ayinleri, keşfettiğiniz gibi biraz farklıdır. Amerika Birleşik Devletleri'nde genellikle arka arkaya 3 toplantı bloğu vardır; bunlara pazar okulu, erkekler ve kadınlar için öğretim zamanı ve genel cemaatin bir araya geldiği ayin toplantısı dahildir. Katıldığınız ilk toplantının, kardeşlerin kutsal yazıların ve modern Kilise liderlerinin sözlerini incelediği Rahiplik toplantısı gibi görünüyor. Bu derslerde genellikle her hafta tek bir eğitmen bulunur. Ayin toplantısı, vaaza eşdeğer bir şeyin duyulacağı yerdir. Mormon ayinleri ile diğer bazı ayinler arasındaki temel fark, kilise toplantılarının odak noktasıdır. Ayin toplantısı düzenlemenin amacı, ayini almak ve vaftizde yapılan antlaşmaları yenilemektir. Ayinin gerçek yönetimi, Mormonlar için en kutsal halka açık toplantıdır. İnsanların konuşmasını ve hatta kişiler arası iletişimi (sosyalleşme) dinlemek sadece ikincildir, ancak önemlidir. Bir mahalle veya yerel cemaatin üyeleri, piskopos veya danışmanları (bir papazın temel eşdeğeri) tarafından konuşmaya davet edilir ve bir konuşma hazırlamak için biraz zamanları olur. Konuşmalar kutsal yazılardan, kişisel deneyimlerden ve tanıklıklardan alınmalı ve Kurtarıcı'ya odaklanmalıdır. Kilise üyelerinin bir ayin toplantısında kürsüde yaptıkları yorumların, Kilise'nin bir konu veya hatta Kilise doktrini hakkındaki resmi görüşünü yansıtmayabileceğini unutmayın. Konuşmalar, katılan herkesi Mesih'e gelmeye, onlara Ruh'un gücünü hissetme ve imanlarını güçlendirme fırsatı vermeye teşvik etmek, ilham vermek ve teşvik etmek içindir. Çoğu zaman üyeler yüreklerinde sorularla gelir ve o gün sözlerde cevaplar bulurlar. Bir piskopos gibi liderlerden gelen öğütler bazen kürsüde verilir, ancak genellikle bu özel ve bireyseldir ve kişisel koşullara dayanır. Piskopos ve danışmanlarının üyelerle düzenli olarak görüşmelerde bulunmaları gerekir. Ücretli din adamları yoktur, bu nedenle tüm hizmet gönüllülük esasına dayanır. Her üyeye ayrıca ayda bir kez ailelerini ziyaret ederek bir gospel mesajı paylaşan, iyilik halini kontrol eden ve özellikle ihtiyaç duyulduğunda bir arkadaş ve destek olan iki "ev öğretmeni" atanır. Bu şekilde, tipik bir vaaz modelinin yerini alabilecek talimatlar verilir. Piskopos, danışmanları ve çağırdığı diğer kişiler bu çabaları organize etmeye yardımcı olur. (Ayrıca afet müdahalesi sırasında çok hızlı ve etkili olduğu kanıtlanmıştır, çünkü ev öğretmenleri öğrettikleri kişiler hakkında hemen rapor verir ve piskoposlar gerekirse bir çabayı koordine eder. Yani gördüğünüz şey görünüşe göre oldukça normaldi. Ayda bir kez bile (ilk Pazar günü), üyelerin konuşma hazırlamayı bıraktığı ve bunun yerine bir saat boyunca Mesih ve gospel hakkında tanıklıklarını dile getirdikleri oruç ve tanıklık toplantısı ayin toplantısı sırasında yapılır. Talimatın üyeden üyeye olduğunu söyleyebilirsiniz, ancak aynı zamanda ilham veren ve talimat veren bir piskopos ve diğer kilise liderlerinin yönlendirmesiyle yönlendirilir.

A partir de un String, ```"123-654321"```, lo que deseo es dividirlo en dos Strings: ```string1=123 string2=654321 ```

Bir String'den, ```"123-654321"```, istediğim onu iki String'e bölmek: ```string1=123 string2=654321 ```

Tres formas diferentes de hacerlo: 1. Utilizando la función ```String.split()``` : ``` String str = "123-654321"; String[] parts = str.split("-"); ``` Esta solución utiliza expresiones regulares, así que no es lo más eficiente si no estas trabajando con ellas. 2. Utilizando la clase ```StringTokenizer``` : ```static private List fastSplit(final String text, final String separator, final boolean emptyStrings){ List result = new ArrayList(); final StringTokenizer st = new StringTokenizer(text, separator, true); String token = null; String lastToken = separator; while (st.hasMoreTokens()) { token = st.nextToken(); if (token.equals(separator)) { if (lastToken.equals(separator) && emptyStrings) { result.add(""); } } else { result.add(token); } lastToken = token; } return result; } ``` El problema con este método es que solo funciona bien cuando el delimitador tiene longitud 1. 3. Implementarlo usando ```String.indexOf()``` : En este caso si funcionará correctamente para delimitadores de cualquier longitud. ```static private List fastSplit2(final String text, final String separator, final boolean emptyStrings) { final List result = new ArrayList(); if (text != null && text.length() > 0) { int index1 = 0; int index2 = text.indexOf(separator); int sepLen = separator.length(); while (index2 >= 0) { String token = text.substring(index1, index2); if (!token.isEmpty() || emptyStrings){ result.add(token); } index1 = index2 + sepLen; index2 = text.indexOf(separator, index1); } if (index1 < text.length() - 1) { result.add(text.substring(index1)); } } return result; } ```

Üç farklı yol: 1. ```String.split()``` fonksiyonunu kullanarak: ``` String str = "123-654321"; String[] parts = str.split("-"); ``` Bu çözüm düzenli ifadeler kullanır, bu nedenle bunlarla çalışmıyorsanız en verimli yöntem değildir. 2. ```StringTokenizer``` sınıfını kullanarak: ``` static private List fastSplit(final String text, final String separator, final boolean emptyStrings){ List result = new ArrayList(); final StringTokenizer st = new StringTokenizer(text, separator, true); String token = null; String lastToken = separator; while (st.hasMoreTokens()) { token = st.nextToken(); if (token.equals(separator)) { if (lastToken.equals(separator) && emptyStrings) { result.add(""); } } else { result.add(token); } lastToken = token; } return result; } ``` Bu yöntemin sorunu, yalnızca sınırlayıcı uzunluğu 1 olduğunda düzgün çalışmasıdır. 3. ```String.indexOf()``` kullanarak uygulamak: Bu durumda, herhangi bir uzunluktaki sınırlayıcılar için düzgün çalışacaktır. ``` static private List fastSplit2(final String text, final String separator, final boolean emptyStrings) { final List result = new ArrayList(); if (text != null && text.length() > 0) { int index1 = 0; int index2 = text.indexOf(separator); int sepLen = separator.length(); while (index2 >= 0) { String token = text.substring(index1, index2); if (!token.isEmpty() || emptyStrings){ result.add(token); } index1 = index2 + sepLen; index2 = text.indexOf(separator, index1); } if (index1 < text.length() - 1) { result.add(text.substring(index1)); } } return result; } ```

What’s the difference between ```\n``` (newline) and ```\r``` (carriage return)? In particular, are there any practical differences between ```\n``` and ```\r```? Are there places where one should be used instead of the other?

```\n``` (yeni satır) ve ```\r``` (satır başı) arasındaki fark nedir? Özellikle, ```\n``` ve ```\r``` arasında pratik farklar var mıdır? Birinin diğerinin yerine kullanılması gereken yerler var mıdır?

In terms of ascii code, it's 3 -- since they're 10 and 13 respectively. But seriously, there are many differences: * in Unix and all Unix-like systems, ```\n``` is the code for end-of-line, ```\r``` means nothing special * as a consequence, in C and most languages that somehow copy it (even remotely), ```\n``` is the standard escape sequence for end of line (translated to/from OS-specific sequences as needed) * in old Mac systems (pre-OS X), ```\r``` was the code for end-of-line instead * in Windows (and many old OSs), the code for end of line is 2 characters, ```\r\n```, in this order * as a surprising consequence (harking back to OSs much older than Windows), ```\r\n``` is the standard line-termination for text formats on the Internet * for electromechanical teletype-like "terminals", ```\r``` commands the carriage to go back leftwards until it hits the leftmost stop (a slow operation), ```\n``` commands the roller to roll up one line (a much faster operation) -- that's the reason you always have ```\r``` before ```\n```, so that the roller can move while the carriage is still going leftwards!-) Wikipedia has a more detailed explanation. * for character-mode terminals (typically emulating even-older printing ones as above), in raw mode, ```\r``` and ```\n``` act similarly (except both in terms of the cursor, as there is no carriage or roller. In practice, in the modern context of writing to a text file, you should always use ```\n``` (the underlying runtime will translate that if you're on a weird OS, e.g., Windows. The only reason to use ```\r``` is if you're writing to a character terminal (or more likely a "console window" emulating it) and want the next line you write to overwrite the last one you just wrote (sometimes used for goofy "ascii animation" effects of e.g. progress bars) -- this is getting pretty obsolete in a world of GUIs, though

ASCII kodları açısından, 3'tür -- sırasıyla 10 ve 13 oldukları için. Ama ciddi olarak, birçok fark vardır: * Unix ve Unix benzeri tüm sistemlerde, ```\n``` satır sonu kodudur, ```\r``` özel bir şey ifade etmez * Sonuç olarak, C'de ve onu bir şekilde kopyalayan çoğu dilde (uzaktan bile), ```\n``` satır sonu için standart kaçış dizisidir (gerektiğinde işletim sistemine özgü dizilere çevrilir) * Eski Mac sistemlerinde (OS X öncesi), ```\r``` bunun yerine satır sonu kodu idi * Windows'ta (ve birçok eski işletim sisteminde), satır sonu kodu 2 karakterdir, ```\r\n```, bu sırayla * Şaşırtıcı bir sonuç olarak (Windows'tan çok daha eski işletim sistemlerine dayanarak), ```\r\n``` İnternet'teki metin biçimleri için standart satır sonlandırıcıdır * Elektromekanik teletip benzeri "terminaller" için, ```\r``` taşıyıcının en sol durağa çarpana kadar geriye gitmesini emreder (yavaş bir işlem), ```\n``` silindirin bir satır yukarı çıkmasını emreder (çok daha hızlı bir işlem) -- bu, ```\n```'den önce her zaman ```\r```'nin olmasının nedenidir, böylece taşıyıcı hala sola doğru giderken silindir hareket edebilir!-) Wikipedia'da daha ayrıntılı bir açıklama var. * Karakter modlu terminaller için (genellikle yukarıda olduğu gibi daha eski yazıcıları taklit eden), ham modda, ```\r``` ve ```\n``` benzer şekilde hareket eder (imleç açısından ikisi de hariç, çünkü taşıyıcı veya silindir yoktur. Uygulamada, modern bir metin dosyasına yazma bağlamında, her zaman ```\n``` kullanmalısınız (temel çalışma zamanı, garip bir işletim sistemindeyseniz bunu çevirecektir, ör. Windows. ```\r``` kullanmanın tek nedeni, bir karakter terminaline (veya büyük olasılıkla onu taklit eden bir "konsol penceresi") yazıyorsanız ve yazdığınız bir sonraki satırın yeni yazdığınız son satırın üzerine yazmasını istiyorsanız (bazen ör. ilerleme çubuklarının "ascii animasyonu" efektleri için kullanılır) -- bu, GUI dünyasında oldukça modası geçmiş bir şeydir

Assume that I am a programmer and I have an NP-complete problem that I need to solve it. What methods are available to deal with NPC problems? Is there a survey or something similar on this topic?

Bir programcı olduğumu ve çözmem gereken NP-tam bir problemim olduğunu varsayalım. NPC problemleriyle başa çıkmak için hangi yöntemler mevcuttur? Bu konu hakkında bir araştırma veya benzeri bir şey var mı?

There are a number of well-studied strategies; which is best in your application depends on circumstance. * Improve worst case runtime Using problem-specific insight, you can often improve the naive algorithm. For instance, there are $O(c^n)$ algorithms for Vertex Cover with $c huge improvement over the naive $\Omega(2^n)$ and might make instance sizes relevant for you tractable. * Improve expected runtime Using heuristics, you can often devise algorithms that are fast on many instances. If those include most that you meet in practice, you are golden. Examples are SAT for which quite involved solvers exist, and the Simplex algorithm (which solves a polynomial problem, but still). One basic technique that is often helpful is branch and bound. * Restrict the problem If you can make more assumptions on your inputs, the problem may become easy. * Structural properties Your inputs may have properties that simplify solving the problem, e.g. planarity, bipartiteness or missing a minor for graphs. See here for some examples of graph classes for which CLIQUE is easy. * Bounding functions of the input Another thing to look at is parameterised complexity; some problems are solvable in time $O(2^kn^m)$ for $k$ some instance parameter (maximum node degree, maximum edge weight, ...) and $m$ constant. If you can bound $k$ by a polylogarithmic function in $n$ in your setting, you get polynomial algorithms. Saeed Amiri gives details in his answer. * Bounding input quantities Furthermore, some problems admit algorithms that run in pseudo-polynomial time, that is their runtime is bounded by a polynomial function in a number that is part of the input; the naive primality check is an example. This means that if the quantities encoded in your instances have reasonable size, you might have simple algorithms that behave well for you. * Weaken the result This means that you tolerate errorneous or incomplete results. There are two main flavors: * Probabilistic algorithms You only get the correct result with some probability. There are some variants, most notable Monte-Carlo and Las-Vegas algorithms. A famous example is the Miller-Rabin primality test. * Approximation algorithms You no longer look for optimal solutions but almost optimal ones. Some algorithms admit relative ("no worse than double the optimum"), others absolute ("no worse than $5$ plus the optimum") bounds on the error. For many problems it is open how well they can be approximated. There are some that can be approximated arbitrarily well in polynomial time, while others are known to not allow that; check the theory of polynomial-time approximation schemes. Refer to Algorithmics for Hard Problems by Hromkovič for a thorough treatment. * Simplicity is beauty: Improved upper bounds for vertex cover by Chen Jianer, Iyad A. Kanj, Ge Xia (2005)

İyi çalışılmış bir dizi strateji vardır; hangisinin uygulamanız için en iyi olduğu duruma bağlıdır. * En kötü durum çalışma zamanını iyileştirin Problemle ilgili içgörü kullanarak, genellikle saf algoritmayı iyileştirebilirsiniz. Örneğin, saf $\Omega(2^n)$'ye göre büyük bir iyileştirme olan $c$ büyük olan Vertex Cover için $O(c^n)$ algoritmaları vardır ve sizin için geçerli olan örnek boyutlarını yönetilebilir hale getirebilir. * Beklenen çalışma zamanını iyileştirin Sezgisel yöntemler kullanarak, genellikle birçok örnekte hızlı olan algoritmalar tasarlayabilirsiniz. Bunlar pratikte karşılaştığınız çoğu şeyi içeriyorsa, altınısınız. Oldukça karmaşık çözücülerin bulunduğu SAT ve Simplex algoritması (polinomik bir problemi çözer, ancak yine de) buna örnektir. Genellikle yardımcı olan temel bir teknik, dallanma ve sınırlamadır. * Problemi sınırlayın Girdileriniz hakkında daha fazla varsayımda bulunabiliyorsanız, problem kolaylaşabilir. * Yapısal özellikler Girdileriniz, problemi çözmeyi basitleştiren düzlemsellik, iki taraflılık veya grafikler için küçük bir öğenin eksikliği gibi özelliklere sahip olabilir. CLIQUE'nin kolay olduğu bazı grafik sınıflarına ilişkin bazı örnekler için buraya bakın. * Girdinin sınırlama işlevleri Bakılması gereken bir diğer şey parametreli karmaşıklıktır; bazı problemler $k$ bazı örnek parametresi (maksimum düğüm derecesi, maksimum kenar ağırlığı, ...) ve $m$ sabiti için $O(2^kn^m)$ süresinde çözülebilir. Ayarınızda $k$'yı $n$'de polinomik bir logaritmik fonksiyonla sınırlayabilirseniz, polinomik algoritmalar elde edersiniz. Saeed Amiri, cevabında ayrıntılar veriyor. * Girdi miktarlarını sınırlama Ayrıca, bazı problemler sözde polinomik sürede çalışan algoritmalara izin verir, yani çalışma zamanları girdinin bir parçası olan bir sayıdaki polinomik bir fonksiyonla sınırlanır; saf asal sayı kontrolü buna bir örnektir. Bu, örneklerinizde kodlanan miktarların makul bir boyuta sahip olması durumunda, sizin için iyi davranan basit algoritmalara sahip olabileceğiniz anlamına gelir. * Sonucu zayıflatın Bu, hatalı veya eksik sonuçlara tahammül ettiğiniz anlamına gelir. İki ana çeşidi vardır: * Olasılıksal algoritmalar Sadece bazı olasılıklarla doğru sonucu alırsınız. Bazı varyantlar vardır, en dikkat çekenleri Monte-Carlo ve Las-Vegas algoritmalarıdır. Ünlü bir örnek Miller-Rabin asal sayı testidir. * Yaklaşım algoritmaları Artık optimum çözümler aramıyorsunuz, bunun yerine neredeyse optimum çözümler arıyorsunuz. Bazı algoritmalar hatada göreli ("optimumdan iki katından daha kötü değil"), diğerleri mutlak ("optimumdan $5$'ten daha kötü değil") sınırlar kabul eder. Birçok problem için ne kadar iyi yaklaşılabilecekleri açıktır. Polinomik sürede keyfi olarak iyi yaklaşılabilen bazıları varken, diğerlerinin buna izin vermediği bilinmektedir; polinom zamanlı yaklaşım şemaları teorisini kontrol edin. Kapsamlı bir inceleme için Hromkovič'in Zor Problemler İçin Algoritmalarına bakın. * Basitlik güzelliktir: Chen Jianer, Iyad A. Kanj, Ge Xia (2005) tarafından vertex cover için geliştirilmiş üst sınırlar

Why are the lights inside commercial airplanes turned off during take off and landing?

Ticari uçakların içindeki ışıklar kalkış ve iniş sırasında neden kapatılır?

This is for safety reasons. Take-off and landing are the two most critical phases of flight and thus, every additional step to ensure survivability, be it even just adjusting the light, is taken. The interior lights or cabin lights are adjusted to match the exterior environment, so that in case of an emergency, especially if the interior lights fail, your eyes are already accustomed to the light setting and you do not require additional valuable seconds for adjustment to a possibly darker or brighter environment. The lights are usually adjusted at dusk, night or dawn to match the exterior environment. If the cabin lights do not fail during an emergency, the dimmed light also makes it easier to identify the "EXIT" signs which illuminate and make the guidance lighting on the floor easier to follow. The bright emergency lighting is more prominent to identify when the cabin light is dimmed, saving valuable seconds as the aircraft is evacuated. This also ties in with having to raise the blinds on the windows. The blinds need to be raised during take-off and landing irrespective of the outside light situation, however, with a darker cabin, any outside light source, especially from fires or other hazards is easier to identify by the crew, making the decision process of whether one side could be inappropriate to use for evacuation faster, e.g. fire on port side --> no evacuation on that side. The blinds are therefore raised to allow a better view for cabin crew of the outside area and external aircraft parts, such as engines, wings, etc.

Bu güvenlik nedenleriyledir. Kalkış ve iniş, uçuşun en kritik iki aşamasıdır ve bu nedenle hayatta kalmayı sağlamak için ışık ayarlama gibi ek adımlar atılır. İç aydınlatma veya kabin ışıkları, dış ortama uyacak şekilde ayarlanır, böylece acil bir durumda, özellikle iç aydınlatma arızalanırsa, gözleriniz zaten ışık ayarına alışmıştır ve muhtemelen daha karanlık veya daha parlak bir ortama uyum sağlamak için ek değerli saniyelere ihtiyacınız olmaz. Işıklar genellikle dış ortama uyacak şekilde alacakaranlıkta, gece veya şafakta ayarlanır. Kabin ışıkları acil bir durumda arızalanmazsa, loş ışık ayrıca aydınlanan ve zemindeki yönlendirme aydınlatmasının takip edilmesini kolaylaştıran "ÇIKIŞ" işaretlerinin tanımlanmasını da kolaylaştırır. Kabin ışığı loş olduğunda parlak acil durum aydınlatması daha belirgindir ve uçak tahliye edilirken değerli saniyeler kazandırır. Bu aynı zamanda pencerelerdeki perdelerin kaldırılmasıyla da ilgilidir. Perdeler, dış ışık durumundan bağımsız olarak kalkış ve iniş sırasında kaldırılmalıdır, ancak daha karanlık bir kabinle, özellikle yangınlardan veya diğer tehlikelerden gelen herhangi bir dış ışık kaynağının mürettebat tarafından tanımlanması daha kolaydır ve bir tarafın tahliye için kullanılmasının uygun olup olmadığına ilişkin karar verme sürecini hızlandırır, örn. liman tarafında yangın --> o tarafta tahliye yok. Bu nedenle perdeler, kabin ekibinin dış alanın ve motorlar, kanatlar vb. gibi dış uçak parçalarının daha iyi görünmesini sağlamak için kaldırılır.

The default behaviour of ```LIKE``` and the other comparison operators, ```=``` etc is case-sensitive. Is it possible make them case-insensitive?

```LIKE``` ve diğer karşılaştırma operatörlerinin, ```=``` vb. varsayılan davranışı büyük/küçük harfe duyarlıdır. Bunları büyük/küçük harfe duyarlı olmayan hale getirmek mümkün mü?

There are 3 main ways to perform a case-insensitive search in Oracle without using full-text indexes. Ultimately what method you choose is dependent on your individual circumstances; the main thing to remember is that to improve performance you must index correctly for case-insensitive searching. 1. Case your column and your string identically. You can force all your data to be the same case by using `UPPER()` or `LOWER()`: ``` select * from my_table where upper(column_1) = upper('my_string'); ``` or ``` select * from my_table where lower(column_1) = lower('my_string'); ``` If `column_1` is not indexed on `upper(column_1)` or `lower(column_1)`, as appropriate, this may force a full table scan. In order to avoid this you can create a function-based index. ``` create index my_index on my_table ( lower(column_1) ); ``` If you're using LIKE then you have to concatenate a `%` around the string you're searching for. ``` select * from my_table where lower(column_1) LIKE lower('my_string') || '%'; ``` 2. Use regular expressions. From Oracle 10g onwards `REGEXP_LIKE()` is available. You can specify the _match_parameter_ `'i'`, in order to perform case-insensitive searching. In order to use this as an equality operator you must specify the start and end of the string, which is denoted by the carat and the dollar sign. ``` select * from my_table where regexp_like(column_1, '^my_string$', 'i'); ``` In order to perform the equivalent of LIKE, these can be removed. ``` select * from my_table where regexp_like(column_1, 'my_string', 'i'); ``` Be careful with this as your string may contain characters that will be interpreted differently by the regular expression engine. 3. Change it at the session level. The NLS_SORT parameter governs the collation sequence for ordering and the various comparison operators, including `=` and LIKE. You can specify a binary, case-insensitive, sort by altering the session. This will mean that every query performed in that session will perform case-insensitive parameters. ``` alter session set nls_sort=BINARY_CI ``` There's plenty of additional information around linguistic sorting and string searching if you want to specify a different language, or do an accent-insensitive search using BINARY_AI. You will also need to change the NLS_COMP parameter; the default value of NLS_COMP is BINARY; but, LINGUISTIC specifies that Oracle should pay attention to the value of NLS_SORT. So, once again, you need to alter the session ``` alter session set nls_comp=LINGUISTIC ``` You may want to create a linguistic index to improve performance ``` create index my_linguistc_index on my_table (NLSSORT(column_1, 'NLS_SORT = BINARY_CI')); ```

Oracle'da tam metin dizinleri kullanmadan büyük/küçük harfe duyarlı olmayan bir arama gerçekleştirmenin 3 ana yolu vardır. Sonuçta hangi yöntemi seçeceğiniz bireysel koşullarınıza bağlıdır; performansı artırmak için büyük/küçük harfe duyarlı arama için doğru şekilde indekslemeniz gerektiğini unutmamak önemlidir. 1. Sütununuzu ve dizenizi aynı şekilde yazın. `UPPER()` veya `LOWER()` kullanarak tüm verilerinizi aynı şekilde yazmaya zorlayabilirsiniz: ``` select * from my_table where upper(column_1) = upper('my_string'); ``` veya ``` select * from my_table where lower(column_1) = lower('my_string'); ``` `column_1`, uygun şekilde `upper(column_1)` veya `lower(column_1)` üzerinde indekslenmezse, bu tam bir tablo taramasına neden olabilir. Bundan kaçınmak için işlev tabanlı bir indeks oluşturabilirsiniz. ``` create index my_index on my_table ( lower(column_1) ); ``` LIKE kullanıyorsanız, aradığınız dizenin etrafına bir `%` eklemeniz gerekir. ``` select * from my_table where lower(column_1) LIKE lower('my_string') || '%'; ``` 2. Düzenli ifadeler kullanın. Oracle 10g'den itibaren `REGEXP_LIKE()` kullanılabilir. Büyük/küçük harfe duyarlı olmayan arama yapmak için `'i'` _eşleşme_parametresini belirtebilirsiniz. Bunu bir eşitlik operatörü olarak kullanmak için, şapka ve dolar işaretiyle gösterilen dizenin başlangıcını ve sonunu belirtmelisiniz. ``` select * from my_table where regexp_like(column_1, '^my_string$', 'i'); ``` LIKE'ın eşdeğerini gerçekleştirmek için bunlar kaldırılabilir. ``` select * from my_table where regexp_like(column_1, 'my_string', 'i'); ``` Dizginiz, düzenli ifade motoru tarafından farklı şekilde yorumlanacak karakterler içerebileceğinden buna dikkat edin. 3. Bunu oturum düzeyinde değiştirin. NLS_SORT parametresi, sıralama ve `=` ve LIKE dahil olmak üzere çeşitli karşılaştırma operatörleri için karşılaştırma sırasını yönetir. Oturumu değiştirerek ikili, büyük/küçük harfe duyarlı olmayan bir sıralama belirtebilirsiniz. Bu, bu oturumda gerçekleştirilen her sorgunun büyük/küçük harfe duyarlı olmayan parametreler gerçekleştireceği anlamına gelir. ``` alter session set nls_sort=BINARY_CI ``` Farklı bir dil belirtmek veya BINARY_AI kullanarak aksan duyarlı olmayan bir arama yapmak istiyorsanız, dilsel sıralama ve dize arama hakkında ek bilgi mevcuttur. Ayrıca NLS_COMP parametresini de değiştirmeniz gerekecektir; NLS_COMP'un varsayılan değeri BINARY'dir; ancak LINGUISTIC, Oracle'ın NLS_SORT değerine dikkat etmesi gerektiğini belirtir. Yani, bir kez daha oturumu değiştirmeniz gerekiyor ``` alter session set nls_comp=LINGUISTIC ``` Performansı artırmak için dilsel bir indeks oluşturmak isteyebilirsiniz ``` create index my_linguistc_index on my_table (NLSSORT(column_1, 'NLS_SORT = BINARY_CI')); ```

I have a new SPA with a stateless authentication model using JWT. I am often asked to refer OAuth for authentication flows like asking me to send 'Bearer tokens' for every request instead of a simple token header but I do think that OAuth is a lot more complex than a simple JWT based authentication. What are the main differences, should I make the JWT authentication behave like OAuth? I am also using the JWT as my XSRF-TOKEN to prevent XSRF but I am being asked to keep them separate? Should I keep them separate? Any help here will be appreciated and might lead to a set of guidelines for the community.

JWT kullanan durumsuz bir kimlik doğrulama modeline sahip yeni bir SPA'm var. Bana her istek için basit bir belirteç başlığı yerine 'Taşıyıcı belirteçleri' göndermemi isteyerek kimlik doğrulama akışları için OAuth'a başvurmam sık sık isteniyor, ancak OAuth'un basit bir JWT tabanlı kimlik doğrulamadan çok daha karmaşık olduğunu düşünüyorum. Ana farklar nelerdir, JWT kimlik doğrulamasını OAuth gibi mi davranmalıyım? Ayrıca XSRF'yi önlemek için JWT'yi XSRF-TOKEN olarak kullanıyorum ancak bunları ayrı tutmam isteniyor? Onları ayrı tutmalı mıyım? Buradaki herhangi bir yardım takdir edilecektir ve topluluk için bir dizi yönergeye yol açabilir.

TL;DR If you have very simple scenarios, like a single client application, a single API then it might not pay off to go OAuth 2.0. On the other hand, if there are lots of different clients (browser-based, native mobile, server-side, etc) then sticking to OAuth 2.0 rules might make it more manageable than trying to roll your own system. ## Detailed Answer JWT (Learn JSON Web Tokens) is just a token format. It defines a compact and self-contained mechanism for transmitting data between parties in a way that can be verified and trusted because it is digitally signed. Additionally, the encoding rules of a JWT also make these tokens very easy to use within the context of HTTP. Being self-contained (the actual token contains information about a given subject), they are also a good choice for implementing stateless authentication mechanisms (aka Look mum, no sessions!). When going this route, the only thing a party must present to be granted access to a protected resource is the token itself, and the token in question can be called a bearer token. In practice, what you're doing can already be classified as bearer token -based. However, do consider you're not using bearer tokens as specified by the OAuth 2.0 related specs (see RFC 6750). That would imply relying on the Authorization HTTP header and using the Bearer authentication scheme. Regarding the use of the JWT to prevent CSRF: Without knowing exact details it's difficult to ascertain the validity of that practice. To be honest, it does not seem correct and/or worthwhile. The following article (Cookies vs Tokens: The Definitive Guide) may be a useful read on this subject, particularly the XSS and XSRF Protection section. One final piece of advice. Even if you don't need to go full OAuth 2.0, I would strongly recommend on passing your access token within the Authorization header instead of going with custom headers. If they are really bearer tokens, follow the rules of RFC 6750. If not, you can always create a custom authentication scheme and still use that header.

ÖZET: Tek bir istemci uygulaması, tek bir API gibi çok basit senaryolarınız varsa OAuth 2.0'a geçmek faydalı olmayabilir. Öte yandan, çok sayıda farklı istemci (tarayıcı tabanlı, yerel mobil, sunucu tarafı vb.) varsa OAuth 2.0 kurallarına bağlı kalmak, kendi sisteminizi oluşturmaya çalışmaktan daha yönetilebilir hale getirebilir. ## Ayrıntılı Cevap JWT (JSON Web Token'larını Öğrenin) yalnızca bir belirteç biçimidir. Dijital olarak imzalandığı için doğrulanabilen ve güvenilebilen bir şekilde taraflar arasında veri iletmek için sıkıştırılmış ve kendi kendine yeten bir mekanizma tanımlar. Ayrıca, bir JWT'nin kodlama kuralları bu belirteçlerin HTTP bağlamında kullanılmasını da çok kolaylaştırır. Kendi kendine yeten (gerçek belirteç, belirli bir konu hakkında bilgi içerir) oldukları için, durumsuz kimlik doğrulama mekanizmalarını (diğer bir deyişle Bak anne, oturum yok!) uygulamak için de iyi bir seçimdir. Bu yola gidildiğinde, bir tarafın korunan bir kaynağa erişim izni almak için sunması gereken tek şey belirtecin kendisidir ve söz konusu belirteç taşıyıcı belirteç olarak adlandırılabilir. Uygulamada, yaptığınız şey zaten taşıyıcı belirteç tabanlı olarak sınıflandırılabilir. Ancak, OAuth 2.0 ile ilgili özelliklerde belirtildiği gibi taşıyıcı belirteçleri kullanmadığınızı unutmayın (bkz. RFC 6750). Bu, Authorization HTTP başlığına güvenmeyi ve Bearer kimlik doğrulama şemasını kullanmayı gerektirir. JWT'nin CSRF'yi önlemek için kullanılmasıyla ilgili olarak: Tam ayrıntıları bilmeden bu uygulamanın geçerliliğini doğrulamak zordur. Dürüst olmak gerekirse, doğru görünmüyor ve/veya buna değmez. Aşağıdaki makale (Çerezler ve Belirteçler: Kesin Kılavuz) bu konu hakkında faydalı bir okuma olabilir, özellikle XSS ve XSRF Koruması bölümü. Son bir tavsiye. Tam OAuth 2.0'a geçmeniz gerekmese bile, erişim belirtecinizi özel başlıklar yerine Authorization başlığı içinde geçirmenizi şiddetle tavsiye ederim. Bunlar gerçekten taşıyıcı belirteçlerse, RFC 6750 kurallarına uyun. Değilse, her zaman özel bir kimlik doğrulama şeması oluşturabilir ve yine de bu başlığı kullanabilirsiniz.

Gostaria de saber se existe alguma forma simples de realizar um upload de arquivos via AJAX + JSON. Se houver, qual seria?

AJAX + JSON kullanarak dosya yüklemenin basit bir yolu olup olmadığını öğrenmek istiyorum. Varsa, bu nasıl olur?

Você pode fazer uploads de arquivos utilizando o método ```POST``` porém deve incluir o FormData com a propriedade ```enctype``` definida como ```multipart/form-data``` para que seus arquivos sejam enviados na requisição. Contudo, a formatação do envio não vai ser um JSON, mas sim no ```enctype``` que você definir no seu ```FormData```, que dependendo da linguagem que você está utilizando no backend vai ter uma forma diferente de interpretar estes dados. * application/x-www-form-urlencoded: é o enctype padrão, todos os valores de espaço são convertidos para "+" e caracteres não padrões são convertidos para representação ANSII HEX; * multipart/form-data: nenhum caractere é convertido, mantendo os valores do formulário intactos, necessário para upload de arquivos; * text/plain: apenas espaços são convertidos em "+"; Sendo essas as possibilidades, o que está sendo trafegado não é um JSON quando vamos comunicar enviando dados para o servidor. Esses dados são serializados para serem entregues dentro da área de data do método que você esta utilizando pra trafegar via HTTP(S) dentro dos formatos apresentados. Durante o upload você pode capturar (nos browsers modernos) evento de progresso do upload, conforme no exemplo abaixo. Exemplo utilizando **jQuery**: **Formulário** ```&lt;form id=&quot;formulario&quot; method=&quot;post&quot; enctype=&quot;multipart/form-data&quot;&gt; &lt;input type=&quot;text&quot; name=&quot;campo1&quot; value=&quot;hello&quot; /&gt; &lt;input type=&quot;text&quot; name=&quot;campo2&quot; value=&quot;world&quot; /&gt; &lt;input name=&quot;arquivo&quot; type=&quot;file&quot; /&gt; &lt;button&gt;Enviar&lt;/button&gt; &lt;/form&gt; ``` **Javascript** ```$("#formulario").submit(function() { var formData = new FormData(this); $.ajax({ url: window.location.pathname, type: 'POST', data: formData, success: function(data) { alert(data) }, cache: false, contentType: false, processData: false, xhr: function() { // Custom XMLHttpRequest var myXhr = $.ajaxSettings.xhr(); if (myXhr.upload) { // Avalia se tem suporte a propriedade upload myXhr.upload.addEventListener('progress', function() { /* faz alguma coisa durante o progresso do upload */ }, false); } return myXhr; } }); }); ```

You can upload files using the ```POST``` method, but you must include the ```FormData``` with the ```enctype``` property set to ```multipart/form-data``` so that your files are sent in the request. However, the submission format will not be JSON, but in the ```enctype``` that you define in your ```FormData```, which depending on the language you are using in the backend will have a different way of interpreting this data. * application/x-www-form-urlencoded: is the default enctype, all space values are converted to "+" and non-standard characters are converted to ANSII HEX representation; * multipart/form-data: no characters are converted, keeping the form values intact, necessary for uploading files; * text/plain: only spaces are converted to "+"; These being the possibilities, what is being trafficked is not a JSON when we communicate by sending data to the server. This data is serialized to be delivered within the data area of the method you are using to traffic via HTTP(S) within the presented formats. During the upload you can capture (in modern browsers) the upload progress event, as in the example below. Example using **jQuery**: **Form** ```&lt;form id=&quot;formulario&quot; method=&quot;post&quot; enctype=&quot;multipart/form-data&quot;&gt; &lt;input type=&quot;text&quot; name=&quot;campo1&quot; value=&quot;hello&quot; /&gt; &lt;input type=&quot;text&quot; name=&quot;campo2&quot; value=&quot;world&quot; /&gt; &lt;input name=&quot;arquivo&quot; type=&quot;file&quot; /&gt; &lt;button&gt;Enviar&lt;/button&gt; &lt;/form&gt; ``` **Javascript** ```$("#formulario").submit(function() { var formData = new FormData(this); $.ajax({ url: window.location.pathname, type: 'POST', data: formData, success: function(data) { alert(data) }, cache: false, contentType: false, processData: false, xhr: function() { // Custom XMLHttpRequest var myXhr = $.ajaxSettings.xhr(); if (myXhr.upload) { // Evaluates if the upload property is supported myXhr.upload.addEventListener('progress', function() { /* do something during upload progress */ }, false); } return myXhr; } }); }); ```

Did the ancients or other pre-industrial civilisations engage in unsustainable practices?

Antikler veya diğer endüstri öncesi medeniyetler sürdürülemez uygulamalara girdiler mi?

Most ancient agricultural practices deplete soil to some degree, but are just fine when population does not exceed certain limits. There are some examples of ancient cultures exhausting natural resources available to them - Pitcairn Island Polynesians, Ancient Puebloans (Anasazi). It's the cause of the semi-nomadic way of life of many early societies - your herds graze the grass into oblivion, you move to another patch to return back when the grass grows back in; or you deplete the soil by overplanting, you move to another spot of land and start over, and so on. But there's an important distinction to be made. Early societies were naturally regulated just as animal population are - by food resources. When food grows scarce, hunger strikes, and humans either start fighting for what's left, reducing population to more manageable levels, or migrate to not yet depleted lands - only cases of actual extinction are from island civilizations which cannot readily move. Meanwhile, globally environment stays balanced, and depleted spots are replenished from outside - slowly healing the damage. Modern humanity has no place to move - all land is already claimed by someone, so we have to make do with what resources we have - and consequently affects the world at global scale, which earlier cultures were incapable of. Sustainability is not about return to pre-industrial way of life - it is unsustainable at modern population levels. It is about preserving the environment in human-habitable state - both by taking less from nature and by increasing effectiveness of usage of what we do need to take.

En eski tarım uygulamalarının çoğu toprağı bir dereceye kadar tüketir ancak nüfus belirli sınırları aşmadığında sorun olmaz. Doğal kaynaklarını tüketen eski kültürlere bazı örnekler vardır - Pitcairn Adası Polinezyalıları, Eski Pueblolar (Anasazi). Bu, birçok erken toplumun yarı göçebe yaşam tarzının nedenidir - sürüleriniz otları yok edene kadar otlatır, otlar yeniden büyüdüğünde geri dönmek için başka bir bölgeye geçersiniz; veya toprağı aşırı ekim yaparak tüketirsiniz, başka bir araziye geçip yeniden başlarsınız vb. Ancak yapılması gereken önemli bir ayrım vardır. Erken toplumlar, hayvan popülasyonları gibi doğal olarak yiyecek kaynakları tarafından düzenlenmiştir. Yiyecekler azaldığında açlık başlar ve insanlar ya kalanlar için savaşmaya başlar, nüfusu daha yönetilebilir seviyelere düşürür ya da henüz tükenmemiş topraklara göç eder - gerçek yok olma vakaları yalnızca kolayca hareket edemeyen ada medeniyetlerinde görülür. Bu arada, küresel çevre dengede kalır ve tükenmiş noktalar dışarıdan yenilenir - hasarı yavaşça iyileştirir. Modern insanlığın hareket edecek yeri yoktur - tüm topraklar zaten birileri tarafından talep edilmiştir, bu nedenle sahip olduğumuz kaynaklarla yetinmek zorundayız - ve sonuç olarak daha önceki kültürlerin yapamadığı küresel ölçekte dünyayı etkiliyoruz. Sürdürülebilirlik, endüstri öncesi yaşam tarzına dönüşle ilgili değildir - modern nüfus seviyelerinde sürdürülemez. İnsanların yaşayabileceği bir durumda çevreyi korumakla ilgilidir - hem doğadan daha az alarak hem de almamız gereken şeylerin kullanım etkinliğini artırarak.

When reading my Bible, I've noticed Joesph's name listed in both the Old and New Testaments; is it the same person or is there more than one Joseph in the Bible?

İncil'imi okurken, hem Eski hem de Yeni Ahit'te Yusuf'un isminin geçtiğini fark ettim; aynı kişi mi yoksa İncil'de birden fazla Yusuf mu var?

There are 3 distinct (fairly) well-known Josephs in the Bible, firstly in the Old Testament (mainly): * Joseph the son of Jacob/Israel (aka The Patriarch Joseph). This Joseph is actually referred to in a few select places in the New Testament: John 4:5; Acts 7:9-18; Hebrews 11:21-22 & Revelation 7:8. However, it's more likely that a Joseph in the New Testament would be one of: * Joseph husband of Mary and surrogate father of Jesus (aka St. Joseph). * Joseph of Arimathea in whose tomb Jesus was laid to rest. There's also another 9 or 10 more obscure Josephs referred to in the Bible*, 4 more in the Old Testament*: * Father of Igal of the tribe of Issachar (cf. Numbers 13:7). * One of the "sons of Asaph" (cf. 1 Chronicles 25:2 & 9). * A descendant of Binnui, a contemporary of Ezra (cf. Ezra 10:38-42). * Head of the priestly family of Shekaniah, a contemporary of Nehemiah (cf. Nehemiah 12:14). And 5 or 6 more in the New Testament: * One of the (half-)brothers of Jesus (often translated as "Joses" - cf. Mark 6:3). * The son of "Mary" and brother of James (possibly/probably The Mary, if so, identical to Joseph number 8. - cf. Mark 15:40 & 47). * The son of Mattathais (and father of Jannai) appearing in Luke's genealogy of Jesus (in which Joseph number 2. also appears - cf. Luke 3:24-25). * The son of Jonam (and father of Judah) also appearing in Luke's genealogy of Jesus (cf. Luke 3:30). * One of the nominees to replace Judas as an apostle, aka Barsabbas aka Justus (cf. Acts 1:23). * A Levite from Cyprus aka Barnabas who probably deserves to be listed amongst the "well-known" Josephs except that he is almost always referred to as Barnabas instead (cf. Acts 4:36). *That is in the Protestant Canon, there are another 3 in the Deuterocanonical books: Son of Oziel (great-grandfather of Judith - cf. Judith 8:1); Son of Zechariah (cf. 1 Maccabees 5); Brother of Judas Maccabeus (aka John - cf. 2 Maccabees 8:22).

İncil'de 3 farklı (oldukça) iyi bilinen Yusuf vardır, ilki Eski Ahit'te (çoğunlukla): * Yakup/İsrail'in oğlu Yusuf (diğer adıyla Patrik Yusuf). Bu Yusuf'a aslında Yeni Ahit'in birkaç seçilmiş yerinde atıfta bulunulur: Yuhanna 4:5; Elçilerin İşleri 7:9-18; İbraniler 11:21-22 ve Vahiy 7:8. Ancak, Yeni Ahit'teki bir Yusuf'un şunlardan biri olması daha olasıdır: * Meryem'in kocası ve İsa'nın üvey babası Yusuf (diğer adıyla Aziz Yusuf). * İsa'nın dinlendirildiği mezarın sahibi Arimatea'lı Yusuf. İncil'de adı geçen 9 veya 10 kadar daha az bilinen Yusuf vardır*, Eski Ahit'te 4 tane daha*: * İssakar kabilesinden İgal'in babası (bkz. Sayılar 13:7). * "Asaf'ın oğullarından" biri (bkz. 1 Tarihler 25:2 ve 9). * Ezra'nın çağdaşı Binnui'nin bir soyundan gelen (bkz. Ezra 10:38-42). * Nehemya'nın çağdaşı Şekanya'nın rahip ailesinin başı (bkz. Nehemya 12:14). Ve Yeni Ahit'te 5 veya 6 tane daha: * İsa'nın (yarım) kardeşlerinden biri (genellikle "Yusuf" olarak çevrilir - bkz. Markos 6:3). * "Meryem"in oğlu ve Yakup'un kardeşi (muhtemelen/belki Meryem ise, 8 numaralı Yusuf ile aynıdır - bkz. Markos 15:40 ve 47). * Matta'nın oğlu (ve Jannai'nin babası) İsa'nın Luka'daki soy ağacında görünür (burada 2 numaralı Yusuf da görünür - bkz. Luka 3:24-25). * Yonam'ın oğlu (ve Yahuda'nın babası) İsa'nın Luka'daki soy ağacında görünür (bkz. Luka 3:30). * Yahuda'nın yerine havari olarak aday gösterilenlerden biri, diğer adıyla Barsabbas diğer adıyla Justus (bkz. Elçilerin İşleri 1:23). * Kıbrıslı bir Levili diğer adıyla Barnabas, neredeyse her zaman Barnabas olarak anıldığı dışında "iyi bilinen" Yusuflar arasında yer almayı hak ediyor (bkz. Elçilerin İşleri 4:36). *Bu Protestan Kanonunda geçer, Deuterokanonik kitaplarda 3 tane daha vardır: Uziel'in oğlu (Judith'in büyük büyükbabası - bkz. Judith 8:1); Zekeriya'nın oğlu (bkz. 1 Makabiler 5); Yahuda Makabi'nin kardeşi (diğer adıyla Yuhanna - bkz. 2 Makabiler 8:22).

Para que serve o "with" no Python?

Python'da "with" ne için kullanılır?

Ele é usado para garantir finalização de recursos adquiridos. Um arquivo, por exemplo é aberto. Quem garante que ele será fechado? Mesmo que você coloque no código de forma explícita que ele deve ser fechado, se ocorrer uma exceção, o código sai de escopo sem executar o resto do código que está em escopo, ele pula o fechamento. Para evitar isto usamos um ```try finally```. O ```finally``` garante a finalização. Como o código fica um pouco longo e este caso é bastante frequente a linguagem providenciou uma forma simplificada com o ```with```. Ele consegue manipular objetos que contenham os métodos ```__enter__()``` e ```__exit__()```. Eles são chamados internamente logo no início da execução do bloco criado e dentro do ```finally``` interno criado no bloco. No exemplo citado deve ficar algo parecido com isto internamente: ```try: __enter__() open(&quot;my_file.txt&quot;) as file: data = file.read() #faça algo com &quot;data&quot; finally: __exit__() ```

Edinilen kaynakların sonlandırılmasını sağlamak için kullanılır. Örneğin bir dosya açılır. Dosyanın kapatılacağını kim garanti eder? Kodu açıkça kapatılması gerektiğini belirtmiş olsanız bile, bir istisna oluşursa kod kapsam dışına çıkar ve kapsam dahilindeki kodun geri kalanını çalıştırmadan atlar ve kapatmayı atlar. Bunu önlemek için ```try finally``` kullanırız. ```finally``` sonlandırmayı garanti eder. Kod biraz uzun olduğu ve bu durum oldukça sık görüldüğü için dil, ```with``` ile basitleştirilmiş bir yol sağlamıştır. ```__enter__()``` ve ```__exit__()``` yöntemlerini içeren nesneleri işleyebilir. Bunlar, oluşturulan bloğun yürütülmesinin hemen başında dahili olarak çağrılır ve blokta oluşturulan dahili ```finally``` içinde çağrılır. Alıntı yapılan örnekte dahili olarak buna benzer bir şey olmalıdır: ```try: __enter__() open(&quot;my_file.txt&quot;) as file: data = file.read() #&quot;data&quot; ile bir şeyler yapın finally: __exit__() ```

The question bothers me since February 2022. Why (legally) are Russian combatants in Ukraine considered soldiers (thus POWs when captured) rather than terrorists? * There is no formal declaration of war. * They are members an organization (Russian military) that commits acts of terrors to civilian population in clear violation of international law of war. Moreover, they either directly or indirectly contribute to the mentioned acts of terror. * Their state (Russia) explicitly claims that there is no war (thus unilaterally waiving the protection of law of war for Russian forces). Why is that particular group of armed people acting in clear violation of Ukrainian law treated as &quot;soldiers in war&quot; rather than state-sponsored criminals? Note, that waiving the protection of law of war does not waive the protection of Ukrainian law (right to due process etc.).

Bu soru beni Şubat 2022'den beri rahatsız ediyor. Neden (yasal olarak) Ukrayna'daki Rus savaşçılar terörist değil de asker (bu nedenle yakalandıklarında savaş esiri) olarak kabul ediliyor? * Resmi bir savaş ilanı yok. * Uluslararası savaş hukukunu açıkça ihlal ederek sivil halka yönelik terör eylemleri gerçekleştiren bir örgütün (Rus ordusu) üyeleridir. Dahası, söz konusu terör eylemlerine doğrudan veya dolaylı olarak katkıda bulunurlar. * Devletleri (Rusya) açıkça savaş olmadığını iddia ediyor (bu nedenle Rus güçleri için savaş hukukunun korumasından tek taraflı olarak feragat ediyor). Ukrayna hukukunu açıkça ihlal eden bu belirli silahlı grup neden devlet destekli suçlulardan ziyade "savaştaki askerler" olarak görülüyor? Savaş hukukunun korumasından feragat etmenin Ukrayna hukukunun korumasından (adil yargılanma hakkı vb.) feragat etmediğine dikkat edin.

The third Geneva convention says in its second article (emphasis added): > the present Convention shall apply to all cases of declared war or of any other armed conflict which may arise between two or more of the High Contracting Parties, even if the state of war is not recognized by one of them. > The Convention shall also apply to all cases of partial or total occupation of the territory of a High Contracting Party, even if the said occupation meets with no armed resistance. The violence in Ukraine qualifies for at least two reasons: it is an armed conflict between two high contracting parties, and it is a case of partial occupation of the territory of a high contracting party. &quot;Members of the armed forces&quot; of Russia who have &quot;fallen into the power of [Ukraine]&quot; are therefore protected by the provisions of the convention as prisoners of war as defined in the convention's fourth article. It follows from this that the parenthetical commentary in the question's third bullet point is incorrect: refusing to call this &quot;military action&quot; a &quot;war&quot; does not in fact &quot;unilaterally waive the protection of law of war for Russian forces.&quot; As to the allegation in the second point, even a prisoner of war who is suspected of committing a war crime is entitled to the convention's protections. Any punishment for the war crime is to be imposed by due process of law. The fact that war crimes may have been committed by other elements of Russia's armed forces is even less of a justification to deny the convention's protections to prisoners who are not individually suspected of war crimes.

Üçüncü Cenevre Sözleşmesi ikinci maddesinde (vurgular eklenmiştir) şöyle der: > Bu Sözleşme, Yüksek Sözleşmeci Tarafların ikisi veya daha fazlası arasında ilan edilmiş savaş veya başka bir silahlı çatışma durumlarında, savaş durumu bunlardan biri tarafından tanınmasa bile uygulanır. > Sözleşme ayrıca, Yüksek Sözleşmeci Tarafın topraklarının kısmen veya tamamen işgal edildiği tüm durumlarda, söz konusu işgal silahlı direnişle karşılaşmasa bile uygulanır. Ukrayna'daki şiddet en az iki nedenden dolayı bu kapsama giriyor: İki yüksek sözleşmeci taraf arasında silahlı bir çatışma ve bir yüksek sözleşmeci tarafın topraklarının kısmen işgali. Bu nedenle, "[Ukrayna'nın] eline düşen" Rusya'nın "silahlı kuvvetlerinin üyeleri", sözleşmenin dördüncü maddesinde tanımlandığı üzere savaş esiri olarak sözleşmenin hükümleriyle korunmaktadır. Bundan, sorunun üçüncü madde işaretindeki parantez içindeki yorumun yanlış olduğu sonucu çıkar: Bu "askeri hareketi" "savaş" olarak adlandırmayı reddetmek, aslında "Rus kuvvetleri için savaş hukukunun korumasından tek taraflı olarak feragat etmek" anlamına gelmez. İkinci maddedeki iddiaya gelince, savaş suçu işlemekten şüphelenilen bir savaş esiri bile sözleşmenin korumalarından yararlanma hakkına sahiptir. Savaş suçu için herhangi bir ceza, yasalara uygun şekilde verilmelidir. Rusya'nın silahlı kuvvetlerinin diğer unsurları tarafından savaş suçları işlenmiş olabileceği gerçeği, savaş suçlarından bireysel olarak şüphelenilmeyen esirlere sözleşmenin korumalarını reddetmek için daha az bir gerekçedir.

What are the major branches of philosophy?

Felsefenin başlıca dalları nelerdir?

The traditional branches of philosophy generally include * Aesthetics * Epistemology * Ethics * Logic * Metaphysics / Ontology We can go ahead and add a few contemporary branches on to this (more examples could certainly be adduced): * Philosophy of Science [referring to the hard sciences] (Mathematics, Technology, etc.) * Philosophy of Politics [referring to the social sciences] (Society, etc.) * Philosophy of Religion [actually two things -- question related to the existence of God or gods AND questions relating to the sociological phenomenon of religion. Generally, referring to the former] * Philosophy of Value (Axiology) * Philosophy of Language * Philosophy of Mind Philosophy of language and philosophy of mind are sometimes done in ways that mirror the philosophy of the hard sciences [e.g. cognitive science] and sometimes not. In addition, we could add many schools and movements (again, more examples could certainly be added). From the 20th century alone, there is: * Phenomenology (Husserl) * Schizoanalysis (Gilles Deleuze and Felix Guattari) * Chaosophy (Felix Guattari) * Non-philosophy (Francois Laruelle) * Existentialism (Sartre, et al.) * Vienna Circle/Logical Positivism Finally, we can also consider the history of philosophy itself as constituting a series of fruitful conjunctions of cultures and eras where ideas were changing. The structure here is taken from Wikipedia's article on the History of Philosophy: * Western philosophy * Ancient philosophy * Medieval philosophy * Renaissance philosophy * Modern philosophy * Contemporary philosophy * Eastern philosophy * Indian philosophy * Persian philosophy * Chinese philosophy * Japanese philosophy * Buddhist philosophy * Abrahamic philosophy * Jewish philosophy * Christian philosophy * Islamic philosophy

Felsefenin geleneksel dalları genellikle şunları içerir: * Estetik * Epistemoloji * Etik * Mantık * Metafizik / Ontoloji Bunlara birkaç çağdaş dal daha ekleyebiliriz (kesinlikle daha fazla örnek verilebilir): * Bilim Felsefesi [sert bilimleri ifade eder] (Matematik, Teknoloji, vb.) * Politika Felsefesi [sosyal bilimleri ifade eder] (Toplum, vb.) * Din Felsefesi [aslında iki şey -- Tanrı'nın veya tanrıların varlığıyla ilgili sorular VE dinin sosyolojik fenomeniyle ilgili sorular. Genellikle ilkiyle ilgilidir] * Değer Felsefesi (Aksioloji) * Dil Felsefesi * Zihin Felsefesi Dil felsefesi ve zihin felsefesi bazen sert bilimlerin felsefesini [örn. bilişsel bilim] yansıtacak şekilde yapılır, bazen de yapılmaz. Ayrıca birçok okul ve akım ekleyebiliriz (yine daha fazla örnek eklenebilir). Sadece 20. yüzyıldan: * Fenomenoloji (Husserl) * Şizoanaliz (Gilles Deleuze ve Felix Guattari) * Kaosofi (Felix Guattari) * Felsefe Dışı (Francois Laruelle) * Varoluşçuluk (Sartre, vd.) * Viyana Çevresi/Mantıksal Pozitivizm Son olarak, felsefe tarihini de fikirlerin değiştiği kültürlerin ve çağların bir dizi verimli birleşimini oluşturan bir şey olarak düşünebiliriz. Buradaki yapı, Vikipedi'nin Felsefe Tarihi makalesinden alınmıştır: * Batı felsefesi * Antik felsefe * Orta Çağ felsefesi * Rönesans felsefesi * Modern felsefe * Çağdaş felsefe * Doğu felsefesi * Hint felsefesi * Fars felsefesi * Çin felsefesi * Japon felsefesi * Budist felsefesi * İbrahimi felsefe * Yahudi felsefesi * Hristiyan felsefesi * İslam felsefesi

Are there any advantages while backpacking to hike during the night and sleep during the day?

Gece yürüyüşü ve gündüz uykusu sırt çantalı yürüyüş yaparken herhangi bir avantaj sağlar mı?

There are several reasons, though not all of them would apply for one's usual holiday trip. 1. Remaining unseen: Obviously, during night its dark and this gives you a fair bit of cover if you want to remain unseen. This reason for traveling at night is common for many hunters in the animal kingdom (and sometimes also their prey), has been used by humans in insecure or hostile territory for centuries and remains a standard technique for some military operations even today. 2. Evading the elements: Hiking throughout the night and resting in the day can be especially useful in hot, arid conditions. For example in deserts, extreme heat during the day and severe cold in the night often come together. Hiking during the night here serves the double purpose of keeping you active and warm when it is cold while allowing you to save water resources during the day. 3. Boosting morale: When conditions get worse (cold, moisture), getting up during the night and starting to hike will not only make you feel warm again, it will also boost your morale. Being active, and actively coping with a bad situation rather than staying miserable in the tent for the rest of the night will make you feel better. 4. You want to avoid tourists: No, seriously, this is a real case in point. Most people travel during the day and one of the reasons we (or at least, I) get outdoors is to enjoy some quietness in the wild. Depending where you are, hiking at night is your best bet to fulfill this dream. 5. Navigation (only very theoretical): Consider a situation where it is all cloudy during the day (so you do not see the sun), you lack a compass and currently have no sense of direction: if you are capable of navigating with the stars, you might consider waiting until dark and hope that the sky will clear up until then.

Bunun birkaç nedeni var, ancak bunların hepsi olağan tatil gezileriniz için geçerli olmayabilir. 1. Görünmemek: Açıkçası, geceleri karanlık olur ve bu, görünmemek istiyorsanız size biraz örtü sağlar. Gece seyahat etmenin bu nedeni, hayvanlar alemindeki birçok avcı için yaygındır (ve bazen de avları için), yüzyıllardır güvensiz veya düşman topraklarında insanlar tarafından kullanılmıştır ve bugün bile bazı askeri operasyonlar için standart bir teknik olmaya devam etmektedir. 2. Unsurlardan kaçınmak: Gece boyunca yürüyüş yapmak ve gündüz dinlenmek, özellikle sıcak, kurak koşullarda faydalı olabilir. Örneğin çöllerde, gündüzleri aşırı sıcak ve geceleri şiddetli soğuk genellikle bir araya gelir. Burada gece yürüyüşü, soğukken sizi aktif ve sıcak tutmanın yanı sıra gün içinde su kaynaklarından tasarruf etmenizi sağlayan çift amaçlı bir amaca hizmet eder. 3. Morali yükseltmek: Koşullar kötüleştiğinde (soğuk, nem), gece kalkıp yürüyüşe başlamak sizi sadece tekrar sıcak hissettirmekle kalmayacak, aynı zamanda moralinizi de yükseltecektir. Aktif olmak ve gecenin geri kalanında çadırda sefil bir şekilde kalmaktansa kötü bir durumla aktif olarak başa çıkmak kendinizi daha iyi hissetmenizi sağlayacaktır. 4. Turistlerden kaçınmak istiyorsunuz: Hayır, cidden, bu konuyla ilgili gerçek bir örnek. Çoğu insan gün içinde seyahat eder ve dışarı çıkmamızın (ya da en azından benim) nedenlerinden biri vahşi doğada biraz sessizliğin tadını çıkarmaktır. Nerede olduğunuza bağlı olarak, gece yürüyüşü bu hayali gerçekleştirmek için en iyi seçeneğinizdir. 5. Navigasyon (sadece çok teorik): Gün boyunca her yerin bulutlu olduğu (bu nedenle güneşi görmüyorsunuz), pusulanızın olmadığı ve şu anda yön duygunuzun olmadığı bir durumu düşünün: yıldızlarla gezinme yeteneğiniz varsa, hava kararana kadar beklemeyi ve gökyüzünün o zamana kadar açılmasını ummayı düşünebilirsiniz.

I have been cautioned against blending: * Traditional fantasy elements Such as magic systems and exotic, less plausible creatures (on a scientific level - magic tends to explain away these beasts) * Traditional sci-fi elements Such as advanced technology and civilizations amidst the stars. I have taken it upon myself to harmonize the two in my current worldbuilding project. I know I cannot be the first. I love the creativity found in both, and it is going well so far. I have been exploring the potential for humanity with both tools at their disposal. (Magic and science, essentially) Why do people advise to stick to one or the other?

Karıştırma konusunda uyarıldım: * Geleneksel fantastik öğeler Büyü sistemleri ve egzotik, daha az inandırıcı yaratıklar gibi (bilimsel düzeyde - büyü bu canavarları açıklama eğilimindedir) * Geleneksel bilimkurgu öğeleri Yıldızlar arasında ileri teknoloji ve medeniyetler gibi. Mevcut dünya inşa etme projemde ikisini uyumlaştırmayı kendime görev edindim. İlk ben olmadığımı biliyorum. Her ikisinde de bulunan yaratıcılığı seviyorum ve şimdiye kadar iyi gidiyor. İnsanlığın her iki araca da sahip olma potansiyelini araştırıyorum. (Aslında büyü ve bilim) İnsanlar neden birine veya diğerine bağlı kalmayı tavsiye ediyor?

Any sufficiently advanced technology is indistinguishable from magic. - Arthur C Clarke There's a reason that science fiction and fantasy are frequently shelved together - separating the two is usually a fools errand. The Dragonriders of Pern features a preindustrial society where flying, firebreathing, teleporting, and telepathic dragons defend the skies from horrible creatures that rain down from above. They could easily be considered pure fantasy - up until the book where they discover the spacecraft that the human ancestors flew in on, and the labs where they bioengineered the dragons. In Star Wars (arguably the most famous science fiction property of all time), the Force is really just space magic called another name. And they do all their fighting with swords. The lists go on and on. Science fiction and fantasy are united in that they explore the impossible. Fantasy uses elements that will never be possible, while science fiction uses elements that theoretically might be possible. But the impossibility is shared. ## Science fiction and fantasy are not a single genre - they are many Epic fantasy (eg Wheel of Time) and space opera (eg Star Wars) are more similar to each other than they are to urban fantasy or "hard" science fiction. In some ways, it's inaccurate to call science fiction and fantasy genres at all. They're setting elements. A romance doesn't stop being a romance because it's set on a space station, and a murder mystery isn't any less mysterious because it was an elf who was murdered. The key to mixing these elements successfully is to understand the expectations of your readers, and meeting those expectations (but in surprising ways). Genre helps define expectations. If you're writing hard SF, readers expect to see a world that's close enough to our own that they can believe that our world could become the world of the story - magic obviously has no place here. On the flip side, urban fantasy readers expect the author to have considered the modern world and how it might interact with the impossible. Extrapolations from science to science fiction may be natural depending on the exact nature of the setting. If the reader has led to expect that the serial killer is a Scooby-Doo villain, then the sudden reveal that the murders were done with actual magic will violate their expectations and frustrate them (in general - there will of course be exceptions). But if the story is framed as a space cop trying to capture a vampire despite not believing that vampires are real, the readers will accept that premise as well as any other.

Yeterince gelişmiş herhangi bir teknoloji sihirden ayırt edilemez. - Arthur C Clarke Bilim kurgu ve fantastik edebiyatın sıklıkla birlikte raflarda yer almasının bir nedeni var - ikisini ayırmak genellikle aptalların işi. Pern Ejderha Binicileri, uçan, ateş püskürten, ışınlanan ve telepatik ejderhaların yukarıdan yağan korkunç yaratıklardan gökleri koruduğu endüstri öncesi bir toplumu konu alıyor. İnsan atalarının içinde uçtuğu uzay aracını ve ejderhaları biyomühendislik yaptıkları laboratuvarları keşfettikleri kitaba kadar kolayca saf fantastik olarak kabul edilebilirlerdi. Star Wars'ta (tartışmasız tüm zamanların en ünlü bilim kurgu özelliği), Güç aslında başka bir isimle anılan uzay büyüsüdür. Ve tüm dövüşlerini kılıçlarla yaparlar. Listeler uzayıp gidiyor. Bilim kurgu ve fantastik edebiyat, imkansızı keşfetmeleri açısından birleşir. Fantastik edebiyat asla mümkün olmayacak unsurları kullanırken, bilim kurgu teorik olarak mümkün olabilecek unsurları kullanır. Ancak imkansızlık paylaşılır. ## Bilim kurgu ve fantastik edebiyat tek bir tür değildir - çoktur Epik fantastik (ör. Zaman Çarkı) ve uzay operası (ör. Star Wars), kentsel fantastik veya "sert" bilim kurgudan birbirine daha çok benzer. Bazı açılardan, bilim kurgu ve fantastik edebiyatı tür olarak adlandırmak yanlıştır. Onlar ayar öğeleridir. Bir aşk romanı, bir uzay istasyonunda geçtiği için aşk romanı olmaktan çıkmaz ve bir cinayet gizemi, öldürülen bir elf olduğu için daha az gizemli olmaz. Bu unsurları başarılı bir şekilde birleştirmenin anahtarı, okuyucularınızın beklentilerini anlamak ve bu beklentileri karşılamaktır (ancak şaşırtıcı şekillerde). Tür, beklentileri tanımlamaya yardımcı olur. Sert SF yazıyorsanız, okuyucular dünyamızın hikayenin dünyası olabileceğine inanabilecekleri kadar kendi dünyamıza yakın bir dünya görmeyi beklerler - sihrin burada yeri yoktur. Öte yandan, kentsel fantastik okuyucuları, yazarın modern dünyayı ve imkansızla nasıl etkileşime girebileceğini düşündüğünü beklerler. Bilimden bilim kurguya ekstrapolasyonlar, ortamın tam doğasına bağlı olarak doğal olabilir. Okuyucu, seri katilin bir Scooby-Doo kötü adamı olduğunu beklemeye yönlendirildiyse, cinayetlerin gerçek sihirle işlendiği ani ifşa, beklentilerini ihlal edecek ve onları hayal kırıklığına uğratacaktır (genel olarak - elbette istisnalar olacaktır). Ancak hikaye, vampirlerin gerçek olduğuna inanmamasına rağmen bir vampiri yakalamaya çalışan bir uzay polisi olarak çerçevelenirse, okuyucular bu öncülü diğerleri kadar kabul edecektir.

Why are prions in animal diets not destroyed by the digestive system?

Hayvan diyetlerindeki prionlar neden sindirim sistemi tarafından yok edilmez?

Proteases are enzymes in your digestive system that help break down food, acting like molecular-sized scissors that cut up proteins. Proteases have clefts, or subpockets, into which proteins fit, where the substrate (protein) gets cut. Infectious or pathogenic prions are resistant to proteases, because of their three-dimensional shape, which hides away parts of the prion that would normally fit in proteases and which would cause the prion to be digested. Prions that do not cause disease — normal prions — have a different three-dimensional shape that allow them to fit into proteases, and so they are not resistant to digestion: A wealth of evidence contends that the infectious pathogen causing the prion diseases, also referred to as spongiform encephalopathies, is solely comprised of PrPSc, the pathogenic isoform of the prion protein (21-23). Both PrPSc and its normal cellular counterpart, PrPC, are encoded by a cellular gene (2, 19). Physical and molecular characterization of PrPSc and PrPC has failed to reveal any chemical differences between the two isoforms (32). However, PrPSc acquires distinctive conformational characteristics upon its conversion from PrPC. Whereas PrPC is soluble in most detergents and can be easily digested by proteases, PrPScis insoluble in detergents and maintains a protease-resistant core, designated PrP27-30, which polymerizes into amyloid (25). Dr. Neena Singh also discovered that prions &quot;piggyback&quot; or attach to another protein called ferritin, as they make their way through the digestive system: Disease-causing prions are thought to have passed into people when they ate beef from infected cattle, triggering the brain wasting condition called new-variant Creutzfeldt-Jakob disease, or vCJD. But researchers have not been sure exactly how prions enter the body. To find out, Neena Singh and her team at Case Western Reserve University in Cleveland, Ohio, mimicked the process of eating and digesting infected meat. They mashed up brain tissue that contained prions from patients who had a form of Creutzfeldt-Jakob disease. They then exposed it to a range of harsh digestive enzymes from the mouth, stomach and intestine, which normally break proteins into pieces. Prions, which are known to be enormously tough, escape this attack almost unscathed, they showed, as does a second type of protein called ferritin, which stores iron and is abundant in meat. The two proteins seem to stick together, they report in the Journal of Neuroscience. The researchers next added the digested slurry to a lab model of the human gut: a growing sheet of cells from the intestinal lining. By attaching fluorescent tags to the two proteins, they showed that they are transported through the cells hand-in-hand. &quot;Prions probably ride piggyback&quot; through the gut wall into the body, Singh says. Attaching to ferritin may provide additional protection from digestion, insofar as this removes prions from the digestive system, where proteases are concentrated.

Proteazlar, proteinleri kesen moleküler boyutlu makaslar gibi davranarak yiyecekleri parçalamaya yardımcı olan sindirim sisteminizdeki enzimlerdir. Proteazların, proteinlerin oturduğu ve substratın (proteinin) kesildiği yarıklar veya alt cepleri vardır. Bulaşıcı veya patojenik prionlar, proteazlara karşı dayanıklıdır çünkü üç boyutlu şekilleri, normalde proteazlara uyan ve prionun sindirilmesine neden olan prionun parçalarını gizler. Hastalığa neden olmayan prionlar (normal prionlar), proteazlara uymalarını sağlayan farklı bir üç boyutlu şekle sahiptir ve bu nedenle sindirime karşı dayanıklı değildirler: Kanıtların çoğu, prion hastalıklarına neden olan bulaşıcı patojenin, süngerimsi ensefalopatiler olarak da bilinen, yalnızca prion proteininin patojenik izoformu olan PrPSc'den oluştuğunu iddia etmektedir (21-23). Hem PrPSc hem de normal hücresel karşılığı PrPC, hücresel bir gen tarafından kodlanır (2, 19). PrPSc ve PrPC'nin fiziksel ve moleküler karakterizasyonu, iki izoform arasında herhangi bir kimyasal farkı ortaya çıkarmada başarısız olmuştur (32). Bununla birlikte, PrPSc, PrPC'den dönüşümü üzerine belirgin konformasyonel özellikler kazanır. PrPC çoğu deterjanda çözünür ve proteazlar tarafından kolayca sindirilebilirken, PrPSc deterjanlarda çözünmez ve amiloidde polimerleşen PrP27-30 olarak adlandırılan proteaz dirençli bir çekirdek korur (25). Dr. Neena Singh ayrıca prionların sindirim sisteminden geçerken "sırtına bindiklerini" veya ferritin adı verilen başka bir proteine bağlandıklarını keşfetti: Hastalığa neden olan prionların, yeni varyant Creutzfeldt-Jakob hastalığı veya vCJD adı verilen beyin erimesi durumunu tetikleyerek, enfekte sığırlardan et yendiğinde insanlara geçtiği düşünülmektedir. Ancak araştırmacılar prionların vücuda tam olarak nasıl girdiğinden emin değiller. Bunu öğrenmek için Cleveland, Ohio'daki Case Western Reserve Üniversitesi'ndeki Neena Singh ve ekibi, enfekte et yeme ve sindirme sürecini taklit etti. Creutzfeldt-Jakob hastalığının bir türüne sahip hastalardan alınan prionlar içeren beyin dokusunu ezdiler. Ardından, normalde proteinleri parçalara ayıran ağız, mide ve bağırsaktan gelen bir dizi sert sindirim enzimine maruz bıraktılar. Son derece dayanıklı olduğu bilinen prionların, ette bol miktarda bulunan ve demiri depolayan ferritin adı verilen ikinci bir protein türü gibi, bu saldırıdan neredeyse yara almadan kurtulduğunu gösterdiler. İki proteinin birbirine yapıştığını Neuroscience dergisinde bildirdiler. Araştırmacılar daha sonra sindirilmiş bulamacı insan bağırsağının bir laboratuvar modeline eklediler: bağırsak astarından büyüyen bir hücre tabakası. İki proteine floresan etiketler ekleyerek, hücreler arasında el ele taşındıklarını gösterdiler. Singh, "Prionlar muhtemelen bağırsak duvarından vücuda 'sırtına binerek' geçiyor" diyor. Ferritine bağlanmak, prionları proteazların yoğunlaştığı sindirim sisteminden uzaklaştırdığı sürece, sindirime karşı ek koruma sağlayabilir.

How slicing in Python works? Please include references where appropriate.

Python'da dilimleme nasıl çalışır? Lütfen uygun yerlere referanslar ekleyin.

The syntax is: ``` a[start:stop] # items start through stop-1 a[start:] # items start through the rest of the array a[:stop] # items from the beginning through stop-1 a[:] # a copy of the whole array ``` There is also the `step` value, which can be used with any of the above: ``` a[start:stop:step] # start through not past stop, by step ``` The key point to remember is that the `:stop` value represents the first value that is not in the selected slice. So, the difference between `stop` and `start` is the number of elements selected (if `step` is 1, the default). The other feature is that `start` or `stop` may be a negative number, which means it counts from the end of the array instead of the beginning. So: ``` a[-1] # last item in the array a[-2:] # last two items in the array a[:-2] # everything except the last two items ``` Similarly, `step` may be a negative number: ``` a[::-1] # all items in the array, reversed a[1::-1] # the first two items, reversed a[:-3:-1] # the last two items, reversed a[-3::-1] # everything except the last two items, reversed ``` Python is kind to the programmer if there are fewer items than you ask for. For example, if you ask for ```a[:-2]``` and ```a``` only contains one element, you get an empty list instead of an error. Sometimes you would prefer the error, so you have to be aware that this may happen. ## Relationship with the ```slice``` object A slice object can represent a slicing operation, i.e.: ``` a[start:stop:step] ``` is equivalent to: ``` a[slice(start, stop, step)] ``` Slice objects also behave slightly differently depending on the number of arguments, similarly to ```range()```, i.e. both ```slice(stop)``` and ```slice(start, stop[, step])``` are supported. To skip specifying a given argument, one might use ```None```, so that e.g. ```a[start:]``` is equivalent to ```a[slice(start, None)]``` or ```a[::-1]``` is equivalent to ```a[slice(None, None, -1)]```. While the ```:```-based notation is very helpful for simple slicing, the explicit use of ```slice()``` objects simplifies the programmatic generation of slicing.

Sözdizimi şu şekildedir: ``` a[start:stop] # start ile stop-1 arasındaki öğeler a[start:] # start ile dizinin geri kalanı arasındaki öğeler a[:stop] # başlangıçtan stop-1'e kadar olan öğeler a[:] # tüm dizinin bir kopyası ``` Yukarıdakilerden herhangi biriyle kullanılabilen `step` değeri de vardır: ``` a[start:stop:step] # start'tan stop'u geçmeyerek, step ile ``` Hatırlanması gereken önemli nokta, `:stop` değerinin seçilen dilimde olmayan ilk değeri temsil etmesidir. Yani, `stop` ile `start` arasındaki fark, seçilen öğe sayısıdır (`step` 1 ise, varsayılan). Diğer özellik, `start` veya `stop`'un negatif bir sayı olabilmesidir, bu da dizinin başlangıcından değil, sonundan sayıldığı anlamına gelir. Yani: ``` a[-1] # dizideki son öğe a[-2:] # dizideki son iki öğe a[:-2] # son iki öğe hariç her şey ``` Benzer şekilde, `step` negatif bir sayı olabilir: ``` a[::-1] # dizideki tüm öğeler, tersine çevrilmiş a[1::-1] # ilk iki öğe, tersine çevrilmiş a[:-3:-1] # son iki öğe, tersine çevrilmiş a[-3::-1] # son iki öğe hariç her şey, tersine çevrilmiş ``` İstediğinizden daha az öğe varsa Python programcıya karşı naziktir. Örneğin, ```a[:-2]``` isterseniz ve ```a``` yalnızca bir öğe içeriyorsa, bir hata yerine boş bir liste alırsınız. Bazen hatayı tercih edersiniz, bu nedenle bunun olabileceğinin farkında olmalısınız. ## ```slice``` nesnesiyle ilişki Bir dilim nesnesi bir dilimleme işlemini temsil edebilir, yani: ``` a[start:stop:step] ``` şuna eşdeğerdir: ``` a[slice(start, stop, step)] ``` Dilim nesneleri de ```range()```'e benzer şekilde, argüman sayısına bağlı olarak biraz farklı davranır, yani hem ```slice(stop)``` hem de ```slice(start, stop[, step])``` desteklenir. Belirli bir argümanı belirtmeyi atlamak için ```None``` kullanılabilir, böylece örneğin ```a[start:]``` ```a[slice(start, None)]```'a veya ```a[::-1]``` ```a[slice(None, None, -1)]```'e eşdeğerdir. ```:``` tabanlı gösterim basit dilimleme için çok yararlı olsa da, ```slice()``` nesnelerinin açıkça kullanılması, dilimlemenin programlı olarak oluşturulmasını basitleştirir.

I am writing a story where a species undergoes devolution. Is there any scientific or plausible way to do this? The process can be instantaneous or may take ages, I do not mind which as I need to weigh my options at this stage. To be clear, the devolution I am thinking of is like taking a human being then devolving him/her to the primate stage, so lets say about as far back as Orrorin tugenensis or Paranthropus where they are in the midst of evolving from primates to Homo erectus. Please note I used human beings as an example to give context but the species undergoing devolution may not necessarily be human. Based on the answers, "devolution" does not exist so had the word in quotes to reflect this.

Türlerin gerileme geçirdiği bir hikaye yazıyorum. Bunu yapmanın bilimsel veya makul bir yolu var mı? Süreç anlık olabilir veya uzun sürebilir, bu aşamada seçeneklerimi değerlendirmem gerektiğinden hangisi olduğu önemli değil. Açık olmak gerekirse, düşündüğüm gerileme, bir insanı alıp onu primat aşamasına indirgemek gibi bir şey, yani Orrorin tugenensis veya Paranthropus'un primatlardan Homo erectus'a evrimleşmelerinin ortasında olduğu kadar geriye gidelim. İnsanları bağlam sağlamak için bir örnek olarak kullandığımı, ancak gerileme geçiren türlerin mutlaka insan olmayabileceğini lütfen unutmayın. Cevaplara dayanarak, "gerileme" diye bir şey yok, bu yüzden bunu yansıtmak için kelimeyi tırnak içine aldım.

Devolution doesn't really ever occur, organisms simply adapt to best suit their environment over time. A good example is cave dwelling Troglodyte type species that have lost the ability to see. They haven't actually devolved to not have eyes, they simply did not need them and evolved to save valuable energy and nutrients by not growing a sight organ that would be useless in their environment. It isn't devolution, it's still evolution since they are changing to better suit their environment. So, at least as far as natural processes go, a species would need to become stuck in an environment for a few hundred thousand years that heavily discourages intellect, sociability, communication skills, culture, and inventiveness. That's a tough one to come up with since such traits are usually the most powerful ones for surviving something. So here's the environment and scenario I'm thinking of. Your smart guy race is in the stone age, its pretty much on par with homo sapiens and where they were at about 10,000-15,000 years ago. But something catastrophic doesn't happen. The world slowly becomes a perfect Eden with very few predators, a perfect climate, and vast endless fields of grain and forests of fruit bearing trees. No ice age, no super-predators like we saw in said ice age. No famines or depredation, no rabid competition between several human subspecies for the same resources. The planet (Henceforth known as paradise) is literally perfect. Too perfect. Why would a species that has as close as possible to absolutely nothing to worry about need to even develop the ability to worry? Those big craniums and complex brains waste space and make childbirth more dangerous than necessary. There is absolutely nothing gained by possessing speech, abstract thought, or cooperative culture when all a species needs to do to be successful is to wander around placidly in small familial groups grazing mindlessly on the limitless amounts of food. Shelter is utterly not necessary since you have a perfect climate, nor is clothing, and food is so ludicrously plentiful there is no need to make tools. Within another 100,000 years your species that was formerly well on their way to developing things like agriculture, warfare, and tribal societies has reverted back to dumb grazers that simply live to eat and reproduce.

Gerileme aslında hiç gerçekleşmez, organizmalar zamanla ortamlarına en uygun şekilde uyum sağlarlar. Bunun iyi bir örneği, görme yeteneklerini kaybetmiş mağara sakinleri Troglodyte türleridir. Aslında gözleri olmamak için gerilememişlerdir, sadece onlara ihtiyaçları yoktu ve ortamlarında işe yaramayacak bir görme organı geliştirmeyerek değerli enerji ve besinleri korumak için evrimleşmişlerdir. Bu gerileme değil, ortamlarına daha iyi uyum sağlamak için değiştikleri için hala evrimdir. Yani, en azından doğal süreçler açısından, bir türün zekayı, sosyalliği, iletişim becerilerini, kültürü ve yaratıcılığı büyük ölçüde engelleyen bir ortamda birkaç yüz bin yıl sıkışıp kalması gerekir. Bu tür özellikler genellikle bir şeyden kurtulmak için en güçlü olanlar olduğundan, böyle bir ortam bulmak zordur. İşte düşündüğüm ortam ve senaryo. Akıllı ırkınız taş devrinde, homo sapiens ile hemen hemen aynı seviyede ve yaklaşık 10.000-15.000 yıl önce oldukları yerde. Ancak felaket bir şey olmuyor. Dünya yavaş yavaş çok az avcının, mükemmel bir iklimin ve uçsuz bucaksız tahıl tarlaları ve meyve veren ağaç ormanlarının olduğu mükemmel bir Eden haline geliyor. Buz çağı yok, söz konusu buz çağında gördüğümüz gibi süper avcılar yok. Kıtlık veya yağma yok, aynı kaynaklar için birkaç insan alt türü arasında çılgın bir rekabet yok. Gezegen (bundan böyle cennet olarak bilinir) kelimenin tam anlamıyla mükemmeldir. Çok mükemmel. Endişelenecek neredeyse hiçbir şeyi olmayan bir türün neden endişelenme yeteneğini geliştirmesi gereksin ki? O büyük kafatasları ve karmaşık beyinler yer israfı yapar ve doğumları gereğinden fazla tehlikeli hale getirir. Bir türün başarılı olmak için yapması gereken tek şey, sınırsız miktarda yiyeceği düşünmeden otlayarak küçük aile grupları halinde sakin bir şekilde dolaşmaksa, konuşma, soyut düşünce veya işbirlikçi kültür sahibi olmanın kesinlikle hiçbir faydası yoktur. Mükemmel bir iklime sahip olduğunuz için barınak kesinlikle gerekli değildir, kıyafet de gerekli değildir ve yiyecek o kadar gülünç derecede boldur ki alet yapmaya gerek yoktur. Bir başka 100.000 yıl içinde, eskiden tarım, savaş ve kabile toplumları gibi şeyleri geliştirme yolunda ilerleyen türünüz, sadece yemek ve üremek için yaşayan aptal otçullara geri dönmüştür.

I've used GEDCOM to transfer data between desktop software and websites, but it all seems a bit old hat. Is there anything better that will mangle* my data less. * For example, GEDCOM can lose some data where the two ends of the system understand a concept which GEDCOM does not have a field for.

Masaüstü yazılımı ve web siteleri arasında veri aktarmak için GEDCOM kullandım ancak hepsi biraz eski moda görünüyor. Verilerimi daha az bozacak daha iyi bir şey var mı? * Örneğin, GEDCOM, sistemin iki ucunun da GEDCOM'un alanı olmayan bir kavramı anladığı bazı verileri kaybedebilir.

GEDCOM is the defacto standard for exchanging genealogical data. There are some problems with GEDCOM. * It is not rich enough to hold all the types of information that different vendor systems manage internally. So exporting GEDCOM from one system may lose information that that system actually holds. Though see point 4 below. * There is enough ambiguity in the definition of GEDCOM that different vendors have interpreted a few parts of the format inconsistently. Though they support the same tags, they can't consistently share data that uses those tags. * Some systems don't implement all parts of the GEDCOM format. So, when they import GEDCOM data that includes those parts, they lose that information. * GEDCOM has facilities that allow different vendors to extend it by adding new tags that allow them to add new types of data to GEDCOM. Others systems that do not use the same set of extensions looe that information on import. There have been a few attempts to create new standards and formats for exchanging genealogical data. An older one that is often mentioned is the GenTech model. Recently there have been two efforts underway, Better GEDCOM and GEDCOM-X. Better GEDCOM is now inactive. However, the currently developing FHISO effort evolved from it. GEDCOM-X is an effort of Family Search (an organ of the LDS) and is currently a work in progress. A number of individuals have also offered up new formats for archiving and tranferring genealogical data. None of these have generated enough traction to attract critical mass of interest.

GEDCOM, soyağacı verilerini değiştirmek için fiili standarttır. GEDCOM ile ilgili bazı sorunlar vardır. * Farklı satıcı sistemlerinin dahili olarak yönettiği tüm bilgi türlerini tutacak kadar zengin değildir. Bu nedenle, GEDCOM'u bir sistemden dışa aktarmak, o sistemin aslında tuttuğu bilgileri kaybetmesine neden olabilir. Yine de aşağıdaki 4. noktaya bakın. * GEDCOM tanımında, farklı satıcıların formatın birkaç bölümünü tutarsız bir şekilde yorumladığı kadar belirsizlik vardır. Aynı etiketleri destekleseler de, bu etiketleri kullanan verileri tutarlı bir şekilde paylaşamazlar. * Bazı sistemler GEDCOM formatının tüm bölümlerini uygulamaz. Bu nedenle, bu bölümleri içeren GEDCOM verilerini içe aktardıklarında bu bilgileri kaybederler. * GEDCOM, farklı satıcıların GEDCOM'a yeni veri türleri eklemelerine olanak tanıyan yeni etiketler ekleyerek onu genişletmelerine olanak tanıyan olanaklara sahiptir. Aynı uzantı kümesini kullanmayan diğer sistemler, içe aktarma sırasında bu bilgileri kaybeder. Soyağacı verilerini değiştirmek için yeni standartlar ve formatlar oluşturmak için birkaç girişimde bulunuldu. Sıkça bahsedilen eski bir model GenTech modelidir. Son zamanlarda, Better GEDCOM ve GEDCOM-X olmak üzere iki çaba yürütülmektedir. Better GEDCOM artık aktif değil. Ancak, şu anda gelişmekte olan FHISO çabası bundan gelişti. GEDCOM-X, Aile Araması'nın (LDS'nin bir organı) bir çabasıdır ve şu anda devam eden bir çalışmadır. Birçok kişi ayrıca soyağacı verilerini arşivlemek ve aktarmak için yeni formatlar sundu. Bunların hiçbiri, kritik ilgi kütlesini çekecek kadar ilgi yaratmadı.

Is it ever possible that ```(a== 1 && a ==2 && a==3)``` could evaluate to true in JavaScript?

```(a== 1 && a ==2 && a==3)``` ifadesinin JavaScript'te true olarak değerlendirilmesi mümkün müdür?

If you take advantage of how == works, you could simply create an object with a custom ```toString``` (or ```valueOf```) function that changes what it returns each time it is used such that it satisfies all three conditions. ``` const a = { i: 1, toString: function () { return a.i++; } } if(a == 1 && a == 2 && a == 3) { console.log('Hello World!'); } ``` The reason this works is due to the use of the loose equality operator. When using loose equality, if one of the operands is of a different type than the other, the engine will attempt to convert one to the other. In the case of an object on the left and a number on the right, it will attempt to convert the object to a number by first calling ```valueOf``` if it is callable, and failing that, it will call ```toString```. I used ```toString``` in this case simply because it's what came to mind, ```valueOf``` would make more sense. If I instead returned a string from ```toString```, the engine would have then attempted to convert the string to a number giving us the same end result, though with a slightly longer path.

== işlevinin nasıl çalıştığından yararlanırsanız, her kullanıldığında döndürdüğü değeri değiştiren özel bir ```toString``` (veya ```valueOf```) işlevine sahip bir nesne oluşturabilirsiniz, böylece üç koşulu da karşılar. ``` const a = { i: 1, toString: function () { return a.i++; } } if(a == 1 && a == 2 && a == 3) { console.log('Hello World!'); } ``` Bunun işe yaramasının nedeni gevşek eşitlik operatörünün kullanılmasıdır. Gevşek eşitlik kullanılırken, işlenenlerden biri diğerinden farklı bir türe aitse, motor birini diğerine dönüştürmeye çalışır. Solda bir nesne ve sağda bir sayı olması durumunda, nesneyi önce çağrılabilirse ```valueOf```'u çağırarak bir sayıya dönüştürmeye çalışır ve başarısız olursa ```toString```'u çağırır. Bu durumda ```toString```'u kullandım çünkü aklıma gelen buydu, ```valueOf``` daha mantıklı olurdu. Bunun yerine ```toString```'dan bir dize döndürseydim, motor daha uzun bir yol olsa da bize aynı sonucu veren dizeyi bir sayıya dönüştürmeye çalışırdı.

Gostaria de saber qual é a real diferença entre o ```String``` (s maiúsculo) e o ```string``` (s minúsculo). Aparentemente os dois têm os mesmos objetivos, porém qual é "melhor" para ser utilizado?

```String``` (büyük S) ve ```string``` (küçük s) arasındaki gerçek farkın ne olduğunu öğrenmek istiyorum. Görünüşe göre ikisinin de hedefleri aynı, ancak hangisi kullanılmak için "daha iyi"?

Já foi dito que ```string``` é apenas um alias para o tipo ```String```. Para deixar claro, não há diferença em performance ou forma como o código é gerado. Há exatamente zero diferença no tratamento de ambas. Elas podem fazer as mesmas coisas, e todos os membros estão disponíveis em qualquer um deles, afinal assim se comporta um alias. Diferenças úteis na utilização e escolha: * ```string``` é apenas uma forma mais simples de usar o tipo ```String``` no C#, ou seja, ```string``` é a forma de &quot;tipar&quot; uma cadeia de caracteres no C# e ```String``` é um tipo do CLR. No C#, dependendo do contexto, é melhor usar uma ou outra forma. O tipo ```String``` presente no namespace ```System``` pode ser usado em qualquer linguagem que se utilize do CLR. * ```string``` não pode ser usado com reflexão. ```String``` deve ser usado no lugar. * ```String``` pode ser usado para criar outros aliases: ``` using str = System.String; //... str s = &quot;Foi usado outro alias para string.&quot;; // a variável 's' é do tipo System.String que é o mesmo que ser string ``` Mas esse é apenas um exemplo, não há necessidade e não é recomendado usar em código real. Existe sim casos que um alias pode ser útil, mas esse apenas dificulta a leitura para quem não está acostumado com isso, sem trazer nenhum benefício. * Há alguns locais que ocorre o oposto e criar um alias pode trazer mais legibilidade ao código. * Em outros casos pode ser apenas estranho usar um ou outro e dificultar a leitura. * Na verdade o tipo ```String``` deve ser usado como ```System.String``` ou onde exista um ```using System```, enquanto que ```string``` pode ser usado em qualquer código que o compilador já entenderá. * ```String``` pode ser usado como identificador válido. ```string``` é uma palavra reservada e não pode ser um identificador. * Há uma diferença na forma como o syntax highlight apresenta ambos. Pois uma forma é tipo e a outra é palavra chave. * Apesar da recomendação geral em usar ```string``` sempre que possível enquanto está programando em C#, há controvérsias no seu uso. Alguns alegam que ```String``` é preferencial para deixar claro, através do Pascal Case, que você está usando um tipo de referência(en). Mas não faz muito sentido porque ```Int32``` é tipo de valor(en) e também usa PascalCase (ou lowerCamelCase). E ainda ele, apesar de ser tipo de referência, tem semântica de valor. Então mesmo que usasse a lógica de Pascal Case para tipo de referência, e Camel Case (ou (UpperCamelCase) para tipo de valor, pela semântica, que é o que importa, ele deveria ser Camel Case, ou seja, deveria começar com minúsculo mesmo. No CLR o estilo de case é usado para ajudar determinar outras características do identificador. * É possível substituir o tipo oficial por outro seu com mesmo nome se fizer tudo corretamente. O *alias *apontará para esse novo tipo que tem o mesmo nome e é colocado da mesma forma. Se ele não for exatamente o mesmo nome (incluindo o namespace) aí ele só pode ser usado opcionalmente o que quase inviabiliza o uso real. Importante lembrar que ele é um tipo como outro qualquer por referência com semântica por valor e algumas facilidades que o compilador dá. O mesmo vale se usar ```String```. Também vale lembrar que não existe tipo primitivo em C# (outra referência). Isso existe só como conceito do CLR, mesmo assim não como algo fundamental. Importante notar que tudo isso é válido para o C#, outras linguagens como Java, ou até mesmo VB.NET podem ter mais diferenças. * Documentação oficial do ```string``` dizendo que é um alias. * FAQ reafirmando sobre aliases de tipos. * ```System.String```. Coloquei no GitHub para referência futura.

It has been said that ```string``` is just an alias for the ```String``` type. To make it clear, there is no difference in performance or how the code is generated. There is exactly zero difference in the treatment of both. They can do the same things, and all members are available in either of them, after all that's how an alias behaves. Useful differences in usage and choice: * ```string``` is just a simpler way to use the ```String``` type in C#, that is, ```string``` is the way to "type" a string in C# and ```String``` is a CLR type. In C#, depending on the context, it is better to use one or the other form. The ```String``` type present in the ```System``` namespace can be used in any language that uses the CLR. * ```string``` cannot be used with reflection. ```String``` should be used instead. * ```String``` can be used to create other aliases: ``` using str = System.String; //... str s = &quot;Another alias for string was used.&quot;; // the 's' variable is of type System.String which is the same as being string ``` But this is just an example, there is no need and it is not recommended to use it in real code. There are indeed cases where an alias can be useful, but this only makes it difficult to read for those who are not used to it, without bringing any benefit. * There are some places where the opposite occurs and creating an alias can make the code more readable. * In other cases it may be just strange to use one or the other and make it difficult to read. * In fact, the ```String``` type should be used as ```System.String``` or where there is a ```using System```, while ```string``` can be used in any code that the compiler will already understand. * ```String``` can be used as a valid identifier. ```string``` is a reserved word and cannot be an identifier. * There is a difference in the way syntax highlight presents both. Because one way is type and the other is keyword. * Despite the general recommendation to use ```string``` whenever possible while programming in C#, there is controversy in its use. Some argue that ```String``` is preferable to make it clear, through Pascal Case, that you are using a reference type. But it doesn't make much sense because ```Int32``` is a value type and also uses PascalCase (or lowerCamelCase). And yet, despite being a reference type, it has value semantics. So even if you used the Pascal Case logic for reference type, and Camel Case (or (UpperCamelCase) for value type, by semantics, which is what matters, it should be Camel Case, that is, it should start with lowercase. In the CLR, the case style is used to help determine other characteristics of the identifier. * It is possible to replace the official type with another one with the same name if you do everything correctly. The *alias * will point to this new type that has the same name and is placed in the same way. If it is not exactly the same name (including the namespace) then it can only be used optionally which almost makes real use impossible. It is important to remember that it is a type like any other by reference with value semantics and some facilities that the compiler gives. The same applies if you use ```String```. It is also worth remembering that there is no primitive type in C# (another reference). This exists only as a concept of the CLR, even so not as something fundamental. It is important to note that all this is valid for C#, other languages such as Java, or even VB.NET may have more differences. * Official documentation of ```string``` saying that it is an alias. * FAQ reaffirming about type aliases. * ```System.String```. I put it on GitHub for future reference.

I'm working on a project solo and have to maintain my own code. Usually code review is done not by the code author, so the reviewer can look at the code with the fresh eyes — however, I don't have such luxury. What practices can I employ to more effectively review my own code?

Bir proje üzerinde tek başıma çalışıyorum ve kendi kodumu sürdürmem gerekiyor. Genellikle kod incelemesi kod yazarı tarafından değil, gözden geçiren kişi kodu yeni gözlerle inceleyebilir - ancak ben bu kadar şanslı değilim. Kendi kodumu daha etkili bir şekilde incelemek için hangi uygulamaları kullanabilirim?

First of all, make use of tools to check as much as you can. Tests (backed up with some reasonable code coverage) will give you some confidence of the correctness of the code. Static analysis tools can catch a lot of best practice things. There will always be issues that you need human eyes on to determine though and you will never do as good a job reviewing your own stuff as someone else, there are some things you can do to help however * Check tests exist and pass (possibly have a target test coverage, though you may need to break this in certain cases, but you should be able to justify why) * Check Static analysis passes (there will also be false negatives here but that is fine as long as you can justify why then its fine to suppress them) * Maintain a check list of further things to check in review (ideally add this as new static analysis rules if possible) make sure you check anything the SA can't check, e.g., are comments still valid, are things named appropriately (naming things is of course, one of the 2 hard problems known to computer science) * If a fault is identified check if the cause is systemic and look at why it wasn't found in earlier tests or reviews This of course is useful when you are reviewing others code as well

Her şeyden önce, olabildiğince çok kontrol etmek için araçlardan yararlanın. Testler (makul bir kod kapsamıyla desteklendiğinde) size kodun doğruluğu konusunda biraz güven verecektir. Statik analiz araçları birçok iyi uygulama konusunu yakalayabilir. Yine de insan gözünün belirlemesi gereken sorunlar her zaman olacaktır ve kendi işinizi başkası kadar iyi gözden geçiremeyeceksiniz, ancak yardımcı olabileceğiniz bazı şeyler var * Testlerin varlığını ve geçerliliğini kontrol edin (muhtemelen bir hedef test kapsamına sahip olun, ancak belirli durumlarda bunu bozmanız gerekebilir, ancak nedenini haklı çıkarabilmelisiniz) * Statik analiz geçişlerini kontrol edin (burada da yanlış negatifler olacaktır ancak nedenini haklı çıkarabildiğiniz sürece bunları bastırmak sorun değil) * İncelemede kontrol edilecek diğer şeylerin bir kontrol listesini tutun (mümkünse bunu yeni statik analiz kuralları olarak ekleyin) SA'nın kontrol edemediği her şeyi kontrol ettiğinizden emin olun, örneğin yorumlar hala geçerli mi, şeyler uygun şekilde adlandırılmış mı (şeyleri adlandırmak elbette bilgisayar biliminde bilinen 2 zor problemden biridir) * Bir hata tespit edilirse, nedenin sistemik olup olmadığını kontrol edin ve önceki testlerde veya incelemelerde neden bulunmadığına bakın Bu elbette başkalarının kodunu incelerken de faydalıdır

Assume an environment with a puppet-managed cluster of different servers - various hardware, software, operating systems, virtual/dedicated, etc. Would you choose meaningful hostnames (mysqlmaster01..99, mysqlslave001..999, vpnprimary, vpnbackup, etc.) or would you prefer meaningless hostnames such as characters from a book or movie? The problem I see with meaningful hostnames is that names usually represent a single service and if a server has more than one purpose it gets really messy (especially if server roles change often). Isn't mapping a service name to an IP address and maintaining that mapping what DNS is supposed to do? What are the advantages and drawbacks of both approaches and what actual problems have you had to tackle with the approach you chose?

Farklı sunuculardan oluşan kukla yönetimli bir kümenin bulunduğu bir ortam varsayın - çeşitli donanımlar, yazılımlar, işletim sistemleri, sanal/özel vb. Anlamlı ana bilgisayar adları (mysqlmaster01..99, mysqlslave001..999, vpnprimary, vpnbackup vb.) mi seçerdiniz yoksa bir kitap veya filmdeki karakterler gibi anlamsız ana bilgisayar adlarını mı tercih ederdiniz? Anlamlı ana bilgisayar adlarında gördüğüm sorun, adların genellikle tek bir hizmeti temsil etmesidir ve bir sunucunun birden fazla amacı varsa gerçekten karmaşık hale gelir (özellikle sunucu rolleri sık sık değişiyorsa). Bir hizmet adını bir IP adresine eşlemek ve bu eşlemeyi sürdürmek DNS'in yapması gereken şey değil midir? Her iki yaklaşımın da avantajları ve dezavantajları nelerdir ve seçtiğiniz yaklaşımla hangi gerçek sorunlarla uğraşmak zorunda kaldınız?

This largely comes down to whether your servers are ```pets``` or ```livestock```. Pets get individual names. They're distinct from each other, and we care about those differences. When one gets sick, we usually try to nurse it back to health. Traditionally, servers have been pets. Livestock get numbers. They're mostly identical, and what differences there are, we don't care about and usually try to minimize. When one gets sick, we put it down and get another one. Fully virtualized servers, especially IaaS servers such as AWS, are livestock. In most complex environments, you have a mix. Your web backends, for instance, are almost certainly livestock. If you need more, you spin up a few more with the standard config; if you don't need as many you turn some off. Your database servers, in some configurations, are pets. There may be a lot of special setup on each; you may even be running them on bare metal instead of virtualization. Of course, in either environment, you can name SERVICES and address those directly. This is a best practice in any case; your developers shouldn't need to know or care what the actual hostname of a service is. The hostname should be a purely operational detail. Think, then, of encoding information that is useful to your ops staff in the hostnames - for instance, it's often helpful to denote which datacenter a server is in.

Bu büyük ölçüde sunucularınızın ```evcil hayvan``` mı yoksa ```hayvancılık``` mı olduğuna bağlıdır. Evcil hayvanların bireysel isimleri vardır. Birbirlerinden farklıdırlar ve bu farklılıklara önem veririz. Biri hastalandığında, genellikle onu tekrar sağlığına kavuşturmaya çalışırız. Geleneksel olarak sunucular evcil hayvan olmuştur. Hayvancılık numaralar alır. Çoğunlukla aynıdırlar ve aralarındaki farkları önemsemeyiz ve genellikle en aza indirmeye çalışırız. Biri hastalandığında, onu yere koyar ve başka bir tane alırız. Tamamen sanallaştırılmış sunucular, özellikle AWS gibi IaaS sunucuları hayvancılıktır. Çoğu karmaşık ortamda bir karışımınız vardır. Örneğin, web arka uçlarınız neredeyse kesinlikle hayvancılıktır. Daha fazlasına ihtiyacınız varsa, standart konfigürasyonla birkaç tane daha açarsınız; daha azına ihtiyacınız yoksa bazılarını kapatırsınız. Bazı konfigürasyonlarda veritabanı sunucularınız evcil hayvanlardır. Her birinde çok fazla özel kurulum olabilir; hatta bunları sanallaştırma yerine çıplak metal üzerinde çalıştırıyor olabilirsiniz. Elbette, her iki ortamda da HİZMETLERİ adlandırabilir ve bunlara doğrudan hitap edebilirsiniz. Bu her durumda en iyi uygulamadır; geliştiricileriniz bir hizmetin gerçek ana bilgisayar adının ne olduğunu bilmek veya önemsemek zorunda kalmamalıdır. Ana bilgisayar adı tamamen operasyonel bir ayrıntı olmalıdır. Ardından, işletim ekibiniz için yararlı olan bilgileri ana bilgisayar adlarına kodlamayı düşünün - örneğin, bir sunucunun hangi veri merkezinde olduğunu belirtmek genellikle yararlıdır.

Best way to start investing, for a young person just starting their career?

Kariyerine yeni başlayan genç bir kişi için yatırım yapmaya başlamanın en iyi yolu?

First off, I highly recommend the book Get a Financial Life. The basics of personal finance and money management are pretty straightforward, and this book does a great job with it. It is very light reading, and it really geared for the young person starting their career. Now, with that out of the way, there's really two kinds of "investing" to think about: 1. Retirement (401k, IRA, SIMPLE, etc) 2. Non-Retirement (Brokerage account, investing in individual stocks, day trading, etc) For most individuals, it is best to take care of #1 first. Most people shouldn't even think about #2 until they have fully funded their retirement accounts, established an emergency fund, and gotten their debt under control. There are lots of financial incentives for retirement investing, both from your employer, and the government. All the more reason to take care of #1 before #2! Your employer probably offers some kind of 401k (or equivalent, like a 403b) with a company-provided match. This is a potential 100% return on your investment after the vesting period. No investment you make on your own will ever match that. Additionally, there are tax advantages to contributing to the 401k. (The money you contribute doesn't count as taxable income.) ***The best way to start investing is to learn about your employer's retirement plan, and contribute enough to fully utilize the employer matching.*** Beyond this, there are also Individual Retirement Accounts (IRAs) you can open to contribute money to on your own. You should open one of these and start contributing, but only after you have fully utilized the employer matching with the 401k. The IRA won't give you that 100% ROI that the 401k will. Keep in mind that retirement investments are pretty much "walled off" from your day-to-day financial life. Money that goes into a retirement account generally can't be touched until retirement age, unless you want to pay lots of taxes and penalties. You generally don't want to put the money for your house down payment into a retirement account. One other thing to note: Your 401K and your IRA is an account that you put money into. Just because the money is sitting in the account doesn't necessarily mean it is invested. You put the money into this account, and then you use this money for investments. How you invest the retirement money is a topic unto itself. Here is a good starting point.

Öncelikle, Get a Financial Life kitabını şiddetle tavsiye ederim. Kişisel finans ve para yönetiminin temelleri oldukça basittir ve bu kitap bu konuda harika bir iş çıkarıyor. Çok hafif bir okuma ve gerçekten kariyerine başlayan gençlere yönelik. Şimdi, bunları bir kenara bırakarak, düşünülmesi gereken iki tür "yatırım" vardır: 1. Emeklilik (401k, IRA, SIMPLE, vb.) 2. Emeklilik Dışı (Aracı kurum hesabı, bireysel hisse senetlerine yatırım, günlük alım satım, vb.) Çoğu kişi için öncelikle 1 numaralı maddeyle ilgilenmek en iyisidir. Çoğu insan, emeklilik hesaplarını tam olarak finanse edene, acil durum fonu oluşturana ve borçlarını kontrol altına alana kadar 2 numaralı maddeyi düşünmemelidir. Hem işvereninizden hem de devletten emeklilik yatırımları için birçok mali teşvik vardır. 2 numaralı maddeden önce 1 numaralı maddeyle ilgilenmek için daha fazla neden! İşvereniniz muhtemelen şirket tarafından sağlanan bir eşleşmeyle bir tür 401k (veya 403b gibi eşdeğeri) sunar. Bu, hak kazanma süresinden sonra yatırımınızın potansiyel %100 getirisidir. Kendi başınıza yaptığınız hiçbir yatırım buna asla ulaşamaz. Ayrıca, 401k'ya katkıda bulunmanın vergi avantajları da vardır. (Yatırım yaptığınız para vergiye tabi gelir olarak sayılmaz.) ***Yatırıma başlamanın en iyi yolu, işvereninizin emeklilik planı hakkında bilgi edinmek ve işveren eşleşmesini tam olarak kullanmak için yeterince katkıda bulunmaktır.*** Bunun ötesinde, kendi başınıza para yatırmak için açabileceğiniz Bireysel Emeklilik Hesapları (IRA'lar) da vardır. Bunlardan birini açmalı ve katkıda bulunmaya başlamalısınız, ancak yalnızca 401k ile işveren eşleşmesini tam olarak kullandıktan sonra. IRA size 401k'nın sağlayacağı %100 ROI'yi vermeyecektir. Emeklilik yatırımlarının günlük finansal hayatınızdan oldukça "duvarla çevrili" olduğunu unutmayın. Emeklilik hesabına giren paraya genellikle emeklilik yaşına kadar dokunulamaz, aksi takdirde çok fazla vergi ve ceza ödemek istersiniz. Genellikle evinizin peşinatını bir emeklilik hesabına yatırmak istemezsiniz. Dikkat edilmesi gereken bir diğer şey: 401K'nız ve IRA'nız para yatırdığınız bir hesaptır. Paranın hesapta durması, mutlaka yatırım yapıldığı anlamına gelmez. Parayı bu hesaba yatırıyorsunuz ve ardından bu parayı yatırımlar için kullanıyorsunuz. Emeklilik parasını nasıl yatırdığınız kendi başına bir konudur. İşte iyi bir başlangıç noktası.

Quantum state teleportation is the quantum information protocol where a qubit is transferred between two parties using an initial shared entangled state, Bell measurement, classical communication and local rotation. Apparently, there is also something called quantum gate teleportation. What is quantum gate teleportation and what is it used for? I am particularly interested in possible applications in simulating quantum circuits.

Kuantum durum ışınlama, bir kubitin iki taraf arasında başlangıçta paylaşılan dolaşık durum, Bell ölçümü, klasik iletişim ve yerel dönüş kullanılarak aktarıldığı kuantum bilgi protokolüdür. Görünüşe göre kuantum kapı ışınlama olarak adlandırılan bir şey de var. Kuantum kapı ışınlama nedir ve ne için kullanılır? Özellikle kuantum devrelerini simüle etmede olası uygulamalarla ilgileniyorum.

Quantum gate teleportation is the act of being able to apply a quantum gate on the unknown state while it is being teleported. This is one of the ways in which measurement-based computation can be described using graph states. Usually, teleportation works by having an unknown quantum state $|\psi\rangle$ held by Alice, and two qubits in the Bell state $|\Psi\rangle=(|00\rangle+|11\rangle)/\sqrt{2}$ shared between Alice and Bob. Alice performs a Bell state measurement, getting one of 4 possible answers and Bob holds on his qubit, depending on the measurement result of Alice, one of the 4 states $|\psi\rangle,X|\psi\rangle,Z|\psi\rangle,ZX|\psi\rangle.$ So, once Bob learns what result Alice got, he can compensate by applying the appropriate Paulis. Let $U$ be a 1-qubit unitary. Assume Alice and Bob share $(\mathbb{I}\otimes U)|\Psi\rangle$ instead of $|\Psi\rangle$. If they repeat the teleportation protocol, Bob now has one of $U|\psi\rangle,UX|\psi\rangle,UZ|\psi\rangle,UZX|\psi\rangle$, which we can rewrite as $U|\psi\rangle,(UXU^\dagger)U|\psi\rangle,(UZU^\dagger)U|\psi\rangle,(UZXU^\dagger)U|\psi\rangle.$ The compensations that Bob has to make for a given measurement result are given by the bracketed terms. Often, these are no worse than the compensations you would have to make for normal teleportation (i.e. just the Pauli rotations). For example, if $U$ is the Hadamard rotation, then the corrections are just $(\mathbb{I},Z,X,XZ)$ respectively. So, you can apply the Hadamard during teleportation just be changing the state that you teleport through (There is a strong connection here to the Choi-Jamiołkowski isomorphism). You can do the same for Pauli gates, and the phase gate $\sqrt{Z}=S$. Moreover, if you repeat this protocol to build up a more complicated computation, it is often sufficient to keep a record of what these corrections are, and to apply them later. Even if you don't only need the Pauli gates (as is the case for $T=\sqrt{S}$), the compensations may be easier than implementing the gate directly. This is the basis of the construction of the fault-tolerant T gate. In fact, you can do something similar to apply a controlled-NOT between a pair of qubits as well. This time, the state you need is $|\Psi\rangle_{A_1B_1}|\Psi\rangle_{A_1B_1}$, and a controlled-NOT applied between $B_1$ and $B_2$. This time, there are 16 possible compensating rotations, but all of them are just about how Pauli operations propagate through the action of a controlled-NOT and, again, that just gives Pauli operations out.

Kuantum kapı ışınlaması, ışınlanırken bilinmeyen bir duruma kuantum kapısı uygulayabilme eylemidir. Bu, ölçüm tabanlı hesaplamanın graf durumları kullanılarak tanımlanabileceği yollardan biridir. Genellikle ışınlama, Alice'in elinde tuttuğu bilinmeyen bir kuantum durumu $|\psi\rangle$ ve Alice ile Bob arasında paylaşılan Bell durumu $|\Psi\rangle=(|00\rangle+|11\rangle)/\sqrt{2}$'de iki kubit ile çalışır. Alice, 4 olası cevaptan birini alarak bir Bell durumu ölçümü gerçekleştirir ve Bob, Alice'in ölçüm sonucuna bağlı olarak 4 durumdan biri olan $|\psi\rangle,X|\psi\rangle,Z|\psi\rangle,ZX|\psi\rangle$ durumunda kubitini tutar. Böylece Bob, Alice'in hangi sonucu aldığını öğrendikten sonra uygun Pauli'leri uygulayarak telafi edebilir. $U$'nun 1 kubitlik bir üniter olduğunu varsayalım. Alice ve Bob'un $|\Psi\rangle$ yerine $(\mathbb{I}\otimes U)|\Psi\rangle$ paylaştığını varsayalım. Işınlama protokolünü tekrar ederlerse, Bob artık $U|\psi\rangle,UX|\psi\rangle,UZ|\psi\rangle,UZX|\psi\rangle$ durumlarından birine sahip olur ve bunları $U|\psi\rangle,(UXU^\dagger)U|\psi\rangle,(UZU^\dagger)U|\psi\rangle,(UZXU^\dagger)U|\psi\rangle$ olarak yeniden yazabiliriz. Bob'un belirli bir ölçüm sonucu için yapması gereken telafiler parantez içindeki terimlerle verilir. Çoğu zaman, bunlar normal ışınlama için yapmanız gereken telafilerden daha kötü değildir (yani sadece Pauli dönüşleri). Örneğin, $U$ Hadamard dönüşü ise, düzeltmeler sırasıyla $(\mathbb{I},Z,X,XZ)$'dir. Yani Hadamard'ı ışınlama sırasında, ışınladığınız durumu değiştirerek uygulayabilirsiniz (Burada Choi-Jamiołkowski izomorfizmiyle güçlü bir bağlantı vardır). Aynı şeyi Pauli kapıları ve faz kapısı $\sqrt{Z}=S$ için de yapabilirsiniz. Dahası, bu protokolü daha karmaşık bir hesaplama oluşturmak için tekrarlarsanız, genellikle bu düzeltmelerin ne olduğunu kaydetmek ve bunları daha sonra uygulamak yeterlidir. Sadece Pauli kapılarını kullanmanız gerekmese bile (bu $T=\sqrt{S}$ için geçerlidir), telafiler kapıyı doğrudan uygulamaktan daha kolay olabilir. Bu, hata toleranslı T kapısının yapısının temelini oluşturur. Aslında, bir çift kubit arasında kontrollü-DEĞİL uygulamak için de benzer bir şey yapabilirsiniz. Bu sefer ihtiyacınız olan durum $|\Psi\rangle_{A_1B_1}|\Psi\rangle_{A_1B_1}$ ve $B_1$ ile $B_2$ arasında uygulanan kontrollü-DEĞİL'dir. Bu sefer 16 olası telafi dönüşü vardır, ancak bunların hepsi Pauli işlemlerinin kontrollü-DEĞİL'in eylemiyle nasıl yayıldığıyla ilgilidir ve yine bu sadece Pauli işlemleri verir.

What does it mean for an album to be remastered?

Bir albümün yeniden düzenlenmesi ne anlama gelir?

Mastering is a separate art from recording or mixing. According to the Wikipedia article, the principle processes of mastering are: * Editing minor flaws. * Applying noise reduction to eliminate clicks, dropouts, hum and hiss. * Adjusting stereo width. * Adding ambience. * Equalize audio across tracks for the purpose of optimized frequency distribution. * Adjust volume. * Dynamic range compression or expansion. * Peak limit. * Dither. The common thread between these processes is that they can be performed on the complete mixed recording, not just on individual tracks of a recording. Because of this, mastering can be performed at any time on any audio source. As for the reason why so many works are remastered, the most likely reason is to keep up with new home theater audio formats. If you have a massive 7.2 surround system, it would be a shame if there wasn't a professionally mastered 7.2 format of "Dark Side of the Moon" to utilize that power. Every time new audio encoding formats become widespread (48kHz at 16bits, 92kHz at 24bits, etc.), your favorite audio source will need to be remastered to sound good in that format.

Mastering, kayıt veya miksajdan ayrı bir sanattır. Wikipedia makalesine göre, masteringin temel süreçleri şunlardır: * Küçük kusurları düzenleme. * Tıklamaları, kesintileri, uğultuyu ve tıslamayı ortadan kaldırmak için gürültü azaltma uygulama. * Stereo genişliğini ayarlama. * Ortam sesi ekleme. * Optimize edilmiş frekans dağılımı amacıyla parçalar arasında sesi eşitleme. * Sesi ayarlama. * Dinamik aralık sıkıştırma veya genişletme. * Tepe sınırlama. * Dither. Bu süreçler arasındaki ortak nokta, bir kaydın yalnızca bireysel parçaları üzerinde değil, tamamlanmış miksli kayıt üzerinde de gerçekleştirilebilmeleridir. Bu nedenle mastering, herhangi bir ses kaynağı üzerinde herhangi bir zamanda gerçekleştirilebilir. Çok sayıda eserin neden yeniden düzenlendiği sorusuna gelince, bunun en olası nedeni yeni ev sinema ses formatlarına ayak uydurmaktır. 7.2 surround sisteminiz varsa, "Dark Side of the Moon"un bu gücü kullanmak için profesyonelce düzenlenmiş 7.2 formatının olmaması utanç verici olurdu. Her yeni ses kodlama formatı yaygınlaştığında (16 bit 48 kHz, 24 bit 92 kHz vb.), favori ses kaynağınızın bu formatta iyi ses çıkarması için yeniden düzenlenmesi gerekir.

What's the best way to iterate over the items in a ```HashMap```?

Bir ```HashMap``` içindeki öğeler üzerinde yinelemenin en iyi yolu nedir?

Extracted from the reference How to Iterate Over a Map in Java: There are several ways of iterating over a ```Map``` in Java. Let's go over the most common methods and review their advantages and disadvantages. Since all maps in Java implement the Map interface, the following techniques will work for any map implementation (```HashMap```, ```TreeMap```, ```LinkedHashMap```, ```Hashtable```, etc.) Method #1: Iterating over entries using a For-Each loop. This is the most common method and is preferable in most cases. It should be used if you need both map keys and values in the loop. ```Map map = new HashMap(); for (Map.Entry entry : map.entrySet()) { System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); } ``` Note that the For-Each loop was introduced in Java 5, so this method is working only in newer versions of the language. Also a For-Each loop will throw ```NullPointerException``` if you try to iterate over a map that is null, so before iterating you should always check for null references. Method #2: Iterating over keys or values using a For-Each loop. If you need only keys or values from the map, you can iterate over keySet or values instead of entrySet. ```Map map = new HashMap(); // Iterating over keys only for (Integer key : map.keySet()) { System.out.println("Key = " + key); } // Iterating over values only for (Integer value : map.values()) { System.out.println("Value = " + value); } ``` This method gives a slight performance advantage over ```entrySet``` iteration (about 10% faster) and is more clean. Method #3: Iterating using Iterator. Using Generics: ```Map map = new HashMap(); Iterator> entries = map.entrySet().iterator(); while (entries.hasNext()) { Map.Entry entry = entries.next(); System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); } ``` Without Generics: ```Map map = new HashMap(); Iterator entries = map.entrySet().iterator(); while (entries.hasNext()) { Map.Entry entry = (Map.Entry) entries.next(); Integer key = (Integer)entry.getKey(); Integer value = (Integer)entry.getValue(); System.out.println("Key = " + key + ", Value = " + value); } ``` You can also use same technique to iterate over ```keySet``` or values. This method might look redundant, but it has its own advantages. First of all, it is the only way to iterate over a map in older versions of Java. The other important feature is that it is the only method that allows you to remove entries from the map during iteration by calling ```iterator.remove()```. If you try to do this during For-Each iteration you will get "unpredictable results" according to Javadoc. From a performance point of view this method is equal to a For-Each iteration. Method #4: Iterating over keys and searching for values (inefficient). ```Map map = new HashMap(); for (Integer key : map.keySet()) { Integer value = map.get(key); System.out.println("Key = " + key + ", Value = " + value); } ``` This might look like a cleaner alternative for method #1, but in practice it is pretty slow and inefficient as getting values by a key might be time-consuming (this method in different Map implementations is 20%-200% slower than method #1). If you have FindBugs installed, it will detect this and warn you about inefficient iteration. This method should be avoided. Conclusion: If you need only keys or values from the map, use method #2. If you are stuck with older version of Java (less than 5) or planning to remove entries during iteration, you have to use method #3. Otherwise use method #1.

Java'da Bir Harita Üzerinde Yineleme Yapma başlıklı referanstan çıkarıldı: Java'da bir ```Map``` üzerinde yineleme yapmanın birkaç yolu vardır. En yaygın yöntemleri gözden geçirelim ve avantajlarını ve dezavantajlarını inceleyelim. Java'daki tüm haritalar Map arayüzünü uyguladığından, aşağıdaki teknikler herhangi bir harita uygulaması (```HashMap```, ```TreeMap```, ```LinkedHashMap```, ```Hashtable``` vb.) için çalışacaktır. Yöntem 1: For-Each döngüsü kullanarak girdiler üzerinde yineleme. Bu en yaygın yöntemdir ve çoğu durumda tercih edilir. Döngüde hem harita anahtarlarına hem de değerlerine ihtiyacınız varsa kullanılmalıdır. ```Map map = new HashMap(); for (Map.Entry entry : map.entrySet()) { System.out.println("Anahtar = " + entry.getKey() + ", Değer = " + entry.getValue()); } ``` For-Each döngüsünün Java 5'te tanıtıldığını, bu nedenle bu yöntemin yalnızca dilin daha yeni sürümlerinde çalıştığını unutmayın. Ayrıca, null olan bir harita üzerinde yineleme yapmaya çalışırsanız For-Each döngüsü ```NullPointerException``` fırlatacaktır, bu nedenle yineleme yapmadan önce her zaman null referansları kontrol etmelisiniz. Yöntem 2: For-Each döngüsü kullanarak anahtarlar veya değerler üzerinde yineleme. Haritadan yalnızca anahtarlara veya değerlere ihtiyacınız varsa, entrySet yerine keySet veya values üzerinde yineleme yapabilirsiniz. ```Map map = new HashMap(); // Yalnızca anahtarlar üzerinde yineleme for (Integer key : map.keySet()) { System.out.println("Anahtar = " + key); } // Yalnızca değerler üzerinde yineleme for (Integer value : map.values()) { System.out.println("Değer = " + value); } ``` Bu yöntem, ```entrySet``` yinelemesine göre hafif bir performans avantajı sağlar (yaklaşık %10 daha hızlı) ve daha temizdir. Yöntem 3: Iterator kullanarak yineleme. Genel Türler Kullanma: ```Map map = new HashMap(); Iterator> entries = map.entrySet().iterator(); while (entries.hasNext()) { Map.Entry entry = entries.next(); System.out.println("Anahtar = " + entry.getKey() + ", Değer = " + entry.getValue()); } ``` Genel Türler Olmadan: ```Map map = new HashMap(); Iterator entries = map.entrySet().iterator(); while (entries.hasNext()) { Map.Entry entry = (Map.Entry) entries.next(); Integer key = (Integer)entry.getKey(); Integer value = (Integer)entry.getValue(); System.out.println("Anahtar = " + key + ", Değer = " + value); } ``` Aynı tekniği ```keySet``` veya değerler üzerinde yineleme yapmak için de kullanabilirsiniz. Bu yöntem gereksiz görünebilir ancak kendi avantajları vardır. Her şeyden önce, Java'nın eski sürümlerinde bir harita üzerinde yinelemenin tek yoludur. Diğer önemli özellik, ```iterator.remove()``` çağrılarak yineleme sırasında haritadan girdileri kaldırmanıza izin veren tek yöntem olmasıdır. For-Each yinelemesi sırasında bunu yapmaya çalışırsanız, Javadoc'a göre "tahmin edilemez sonuçlar" alırsınız. Performans açısından bu yöntem, For-Each yinelemesine eşittir. Yöntem 4: Anahtarlar üzerinde yineleme ve değerleri arama (etkisiz). ```Map map = new HashMap(); for (Integer key : map.keySet()) { Integer value = map.get(key); System.out.println("Anahtar = " + key + ", Değer = " + value); } ``` Bu, yöntem 1 için daha temiz bir alternatif gibi görünebilir, ancak pratikte bir anahtara göre değerleri almak zaman alıcı olabileceğinden oldukça yavaş ve etkisizdir (bu yöntem farklı Harita uygulamalarında yöntem 1'den %20-%200 daha yavaştır). FindBugs yüklüyse bunu algılar ve etkisiz yineleme konusunda sizi uyarır. Bu yöntemden kaçınılmalıdır. Sonuç: Haritadan yalnızca anahtarlara veya değerlere ihtiyacınız varsa, yöntem 2'yi kullanın. Eski bir Java sürümüne (5'ten küçük) takılı kaldıysanız veya yineleme sırasında girdileri kaldırmayı planlıyorsanız, yöntem 3'ü kullanmanız gerekir. Aksi takdirde yöntem 1'i kullanın.

Why did people start using CO2 (instead of e.g. oxygen) for carbonated drinks?

İnsanlar neden karbonatlı içecekler için CO2'yi (örneğin oksijen yerine) kullanmaya başladı?

CO2 tastes good! Carbonated water is actually a weak carbonic acid solution; this is what you taste. It's like "salt and pepper", but for water. Slightly acidic water is usually popular, hence lemon juice is sometimes used to taint a jug of water in times when no carbonated water is available. Carbonated water releases CO2 bubbles for many minutes after pressure is released (dissolved carbonic acid reforming), which is an important presentation effect that other gases do not generally have. In many countries the local water supply is slightly alkaline (due to limestone rock being very common), and this can leave a bad after-taste, and make food in your mouth taste soapy. The addition of weak acids to water helps with neutralising this effect. Around the world, some lucky towns have natural springs with effervescent water (carbonated water), and man-made carbonated water is just imitating this. In history people have often travelled great distances to try effervescent water, so its popularity is well recorded. Nitrogen is used for water pressurisation in brewing and cooking as it leaves little or no taste, and generally does not form other chemical compounds. It's used mainly when bubbles are required, but not an acidic taste. Oxygen is unsuitable for water pressurisation as very little can be dissolved at normal soda pressures, and it has no taste, but may readily form unwanted chemical compounds. In the 18th century, Joseph Priestley was the first person to document this manufacturing discovery. He noted precisely that it tasted good, and that it was similar to the German Selters water. He was discovering "airs" (gases), and uniquely identified quite a few different gases. CO2 was the only one he listed as tasting good. His cheap source of CO2 was the fermenting grains from the nearby brewery.

CO2 lezzetlidir! Karbonatlı su aslında zayıf bir karbonik asit çözeltisidir; tattığınız şey budur. Su için "tuz ve karabiber" gibidir. Hafif asitli su genellikle popülerdir, bu nedenle karbonatlı su bulunmadığında bazen bir sürahi suyu lekelemek için limon suyu kullanılır. Karbonatlı su, basınç serbest bırakıldıktan sonra (çözünmüş karbonik asidin yeniden oluşması) uzun süreler boyunca CO2 kabarcıkları açığa çıkarır; bu, diğer gazların genellikle sahip olmadığı önemli bir sunum etkisidir. Birçok ülkede yerel su kaynağı hafif alkalidir (kireçtaşı kayasının çok yaygın olması nedeniyle) ve bu kötü bir tat bırakabilir ve ağzınızdaki yiyeceklerin sabunlu bir tat almasına neden olabilir. Suya zayıf asitlerin eklenmesi bu etkiyi nötralize etmeye yardımcı olur. Dünya çapında, bazı şanslı kasabalar, köpüklü su (karbonatlı su) içeren doğal kaynaklara sahiptir ve yapay karbonatlı su bunu taklit etmektedir. Tarihte insanlar köpüklü suyu denemek için genellikle uzun mesafeler kat etmişlerdir, bu nedenle popülaritesi iyi bir şekilde kaydedilmiştir. Azot, bira yapımında ve yemek pişirmede su basıncı için kullanılır çünkü çok az veya hiç tat bırakmaz ve genellikle diğer kimyasal bileşikler oluşturmaz. Esas olarak kabarcıklar gerektiğinde, ancak asitli bir tat olmadığında kullanılır. Oksijen, su basıncı için uygun değildir çünkü normal soda basınçlarında çok azı çözülebilir ve tadı yoktur, ancak kolayca istenmeyen kimyasal bileşikler oluşturabilir. 18. yüzyılda Joseph Priestley, bu üretim keşfini belgeleyen ilk kişiydi. Lezzetli olduğunu ve Alman Selters suyuna benzediğini tam olarak belirtti. "Hava"ları (gazları) keşfediyordu ve benzersiz bir şekilde birkaç farklı gazı tanımladı. CO2, lezzetli olarak listelediği tek gazdı. Ucuz CO2 kaynağı, yakındaki bira fabrikasından fermente olan tahıllardı.

Say I have a file ```/templates/apple``` and I want to * put it in two different places and then * remove the original. So, ```/templates/apple``` will be copied to ```/templates/used``` AND ```/templates/inuse``` and then after that I’d like to remove the original. Is ```cp``` the best way to do this, followed by ```rm```? Or is there a better way? I want to do it all in one line so I’m thinking it would look something like: ```cp /templates/apple /templates/used | cp /templates/apple /templates/inuse | rm /templates/apple ``` Is this the correct syntax?

Diyelim ki ```/templates/apple``` adında bir dosyam var ve bunu * iki farklı yere koymak ve sonra * orijinali kaldırmak istiyorum. Yani, ```/templates/apple``` ```/templates/used``` VE ```/templates/inuse``` kopyalanacak ve bundan sonra orijinali kaldırmak istiyorum. Bunu yapmanın en iyi yolu ```cp``` mi, ardından ```rm``` mi? Yoksa daha iyi bir yol var mı? Her şeyi tek satırda yapmak istiyorum, bu yüzden şöyle bir şey olacağını düşünüyorum: ```cp /templates/apple /templates/used | cp /templates/apple /templates/inuse | rm /templates/apple ``` Bu doğru söz dizimi mi?

You are using ```|``` (pipe) to direct the output of a command into another command. What you are looking for is ```&&``` operator to execute the next command only if the previous one succeeded: ```cp /templates/apple /templates/used && cp /templates/apple /templates/inuse && rm /templates/apple ``` Or ```cp /templates/apple /templates/used && mv /templates/apple /templates/inuse ``` To summarize (non-exhaustively) bash's command operators/separators: * ```|``` pipes (pipelines) the standard output (```stdout```) of one command into the standard input of another one. Note that ```stderr``` still goes into its default destination, whatever that happen to be. * ```|&```pipes both ```stdout``` and ```stderr``` of one command into the standard input of another one. Very useful, available in bash version 4 and above. * ```&&``` executes the right-hand command of ```&&``` only if the previous one succeeded. * ```||``` executes the right-hand command of ```||``` only it the previous one failed. * ```;``` executes the right-hand command of ```;``` always regardless whether the previous command succeeded or failed. Unless ```set -e``` was previously invoked, which causes ```bash``` to fail on an error.

Bir komutun çıktısını başka bir komuta yönlendirmek için ```|``` (dikey çizgi) kullanıyorsunuz. Aradığınız şey, yalnızca önceki komut başarılı olursa sonraki komutu çalıştıran ```&&``` operatörüdür: ```cp /templates/apple /templates/used && cp /templates/apple /templates/inuse && rm /templates/apple ``` Veya ```cp /templates/apple /templates/used && mv /templates/apple /templates/inuse ``` Bash'in komut operatörlerini/ayırıcılarını (kapsamlı olmayan bir şekilde) özetlemek gerekirse: * ```|``` bir komutun standart çıktısını (```stdout```) başka bir komutun standart girdisine yönlendirir. ```stderr```'in ne olursa olsun varsayılan hedefine gittiğini unutmayın. * ```|&``` bir komutun hem ```stdout```'unu hem de ```stderr```'ini başka bir komutun standart girdisine yönlendirir. Çok kullanışlıdır, bash sürüm 4 ve üzeri sürümlerde bulunur. * ```&&```, yalnızca önceki komut başarılı olursa ```&&```'nin sağ tarafındaki komutu çalıştırır. * ```||```, yalnızca önceki komut başarısız olursa ```||```'nin sağ tarafındaki komutu çalıştırır. * ```;```, önceki komutun başarılı veya başarısız olmasına bakılmaksızın ```;```'nin sağ tarafındaki komutu her zaman çalıştırır. ```set -e``` daha önce çağrılmadığı sürece, bu ```bash```'in bir hata durumunda başarısız olmasına neden olur.

When are Decision Diagrams the right way to model and solve a problem?

Karar Diyagramları bir problemi modellemek ve çözmek için doğru yol ne zaman olur?

Decision diagrams (DDs) are most effective when they can compactly represent a large (perhaps exponential) set of solutions. This is done by merging equivalent states in each layer. To make decision diagrams scalable, we can use relaxed decision diagrams which allow merging nodes that are not necessarily equivalent. Relaxed decision diagrams provide dual bounds on the objective function -- a larger width can produce a stronger bound. The relationship between the size of the decision diagram and the underlying combinatorial structure of the problem is well studied in the computer science literature; see for example the textbook by Wegener. The most important feature that influences the size is the variable ordering. We can use this to come up with some general guidelines on when a DD may be successful for combinatorial optimization: * The problem has a sequential structure, and decisions for stage $i$ depend only on the decisions made in stages $i-k$ through $i-1$, for small $k$. * The induced width of the constraint graph of the problem is small. * For a MIP model, the constraint matrix has a small bandwidth. * For knapsack-like problems, the maximum `budget' is relatively small. Note that in some of the above cases, precise characterization of 'small' may yield (pseudo-)polynomial bounds on the size of the exact DD. In practice, relaxed DDs will always have polynomial size. There are several areas of combinatorial optimization in which decision diagrams have been successfully applied: * Sequencing and routing problems. For example, single machine scheduling with setup times, time windows, and/or precedence constraints, which can also be applied to constrained traveling salesperson problems. A similar decision diagram representation was used by Grubhub to solve pickup-and-delivery problems. * Decomposition and embedding in MIP models. Decision diagrams have been used to represent subproblems in MIP models that are otherwise difficult to linearize. For example, to represent nonlinear objective functions, constrained employee schedules, or nonlinear circuit design. DDs have also been used in column generation. * Graph-theoretic problems. Examples include set covering, maximum independent set, and maximum cut. * Constraint programming. Constraint propagation based on (relaxed) decision diagrams can be much more effective than propagating domains of individual variables. This was first demonstrated on overlapping alldifferent constraints.

Karar diyagramları (DD'ler), büyük (belki de üstel) bir çözüm kümesini sıkıştırılmış bir şekilde temsil edebildiklerinde en etkilidir. Bu, her katmanda eşdeğer durumları birleştirerek yapılır. Karar diyagramlarını ölçeklenebilir hale getirmek için, mutlaka eşdeğer olmayan düğümleri birleştirmeye izin veren gevşetilmiş karar diyagramları kullanabiliriz. Gevşetilmiş karar diyagramları, hedef fonksiyon üzerinde ikili sınırlar sağlar -- daha büyük bir genişlik daha güçlü bir sınır üretebilir. Karar diyagramının boyutu ile problemin altta yatan kombinatoryal yapısı arasındaki ilişki, bilgisayar bilimi literatüründe iyi incelenmiştir; örneğin Wegener'in ders kitabına bakın. Boyutu etkileyen en önemli özellik değişken sıralamasıdır. Bunu, bir DD'nin kombinatoryal optimizasyon için ne zaman başarılı olabileceğine dair bazı genel yönergeler oluşturmak için kullanabiliriz: * Problemin ardışık bir yapısı vardır ve aşama $i$ için kararlar yalnızca $i-k$ ile $i-1$ aşamalarında verilen kararlara bağlıdır, $k$ küçük bir sayıdır. * Problemin kısıtlama grafiğinin türetilmiş genişliği küçüktür. * Bir MIP modeli için, kısıtlama matrisinin küçük bir bant genişliği vardır. * Çanta tipi problemler için, maksimum `bütçe' nispeten küçüktür. Yukarıdaki durumlardan bazılarında, 'küçük'ün kesin karakterizasyonunun, kesin DD'nin boyutu üzerinde (psödo-)polinomsal sınırlar üretebileceğini unutmayın. Uygulamada, gevşetilmiş DD'ler her zaman polinomsal boyuta sahip olacaktır. Karar diyagramlarının başarıyla uygulandığı birkaç kombinatoryal optimizasyon alanı vardır: * Sıralı ve yönlendirme problemleri. Örneğin, kurulum süreleri, zaman pencereleri ve/veya öncelik kısıtlamaları olan tek makineli planlama, kısıtlanmış gezgin satıcı problemlerine de uygulanabilir. Benzer bir karar diyagramı gösterimi, Grubhub tarafından teslim alma ve teslim etme problemlerini çözmek için kullanılmıştır. * MIP modellerinde ayrıştırma ve yerleştirme. Karar diyagramları, aksi takdirde doğrusallaştırılması zor olan MIP modellerindeki alt problemleri temsil etmek için kullanılmıştır. Örneğin, doğrusal olmayan hedef fonksiyonları, kısıtlanmış çalışan programlarını veya doğrusal olmayan devre tasarımını temsil etmek için. DD'ler ayrıca sütun üretiminde de kullanılmıştır. * Grafik teorik problemler. Örnekler arasında küme örtüsü, maksimum bağımsız küme ve maksimum kesit bulunur. * Kısıtlama programlama. (Gevşetilmiş) karar diyagramlarına dayalı kısıtlama yayılımı, bireysel değişkenlerin alanlarını yaymaktan çok daha etkili olabilir. Bu ilk olarak örtüşen tüm farklı kısıtlamalar üzerinde gösterilmiştir.

Essentially, I have a protagonist who I set up as a 'main' good guy in one of my series. However, in my final series, I intend to make him turn to the dark side and oppose my other protagonists (from my other series). It's clear in his series that the protagonist-turned-antagonist is very devious, and he has had hostile intentions previously towards the protagonists of the other series. My question: Should I avoid turning my protagonist into an antagonist? Are there any foreseeable problems with this? Will this be a problem for readers? Any tips or tricks to handle this?

Temelde, serilerimden birinde "ana" iyi adam olarak ayarladığım bir kahramanım var. Ancak, son serimde, karanlık tarafa geçmesini ve diğer kahramanlarıma (diğer serilerimden) karşı çıkmasını planlıyorum. Kahramanın kötü adama dönüştüğü serisinde, çok sinsi olduğu ve daha önce diğer serilerin kahramanlarına karşı düşmanca niyetleri olduğu açık. Sorularım: Kahramanımı kötü adama dönüştürmekten kaçınmalı mıyım? Bununla ilgili öngörülebilir sorunlar var mı? Bu okuyucular için bir sorun olacak mı? Bunu ele almak için ipuçları veya püf noktaları var mı?

Sounds like a great idea! Seriously though: the antagonist is the single most important character to any plot. The very best antagonists have motivations and feelings that readers can understand and empathize with. A former protagonist as an antagonist sounds really good. Both the reader and the author should be in for a fun ride, because it is very likely you will see your character grow in ways you didn't expect when you had them boxed in as a "good guy". Think about people you know in real life. If you really observe people, you come to understand that nobody is a "good guy". Sure there are people who are generally good and generally do good things, but nobody is perfect, and even the best people have thoughts and motivations you may not approve of. Even more interesting is the fact that two people can be absolutely opposed to one another without either one being objectively "wrong" or "evil". They might just have goals and motivations that are diametrically opposed. Imagine a city council wants more tax money to build a park. A local business wants to pay less tax money so they can afford to give Christmas bonuses. The business owner isn't "evil", in fact, he wants to give Christmas bonuses! The city council isn't "evil" either, they just want a park for the kids. Sometimes goals just conflict in an irreconcilable way. That's the real world. That kind of plot provides a lot more food for thought than a two dimensional "good versus evil" morning cartoon romp.

Harika bir fikir gibi görünüyor! Şaka bir yana: Antagonist, herhangi bir olay örgüsündeki en önemli karakterdir. En iyi antagonistlerin, okuyucuların anlayabileceği ve empati kurabileceği motivasyonları ve duyguları vardır. Antagonist olarak eski bir kahraman kulağa gerçekten iyi geliyor. Hem okuyucu hem de yazar eğlenceli bir yolculuğa çıkmalı, çünkü karakterinizin "iyi adam" olarak kısıtlandığında beklemediğiniz şekillerde büyüdüğünü görme ihtimaliniz çok yüksek. Gerçek hayatta tanıdığınız insanları düşünün. İnsanları gerçekten gözlemlerseniz, kimsenin "iyi adam" olmadığını anlarsınız. Elbette genel olarak iyi olan ve genellikle iyi şeyler yapan insanlar vardır, ancak kimse mükemmel değildir ve en iyi insanların bile onaylamayabileceğiniz düşünceleri ve motivasyonları vardır. Daha da ilginci, iki kişinin nesnel olarak "yanlış" veya "kötü" olmadan birbirine tamamen karşı çıkabilmesidir. Sadece taban tabana zıt hedefleri ve motivasyonları olabilir. Bir belediye meclisinin bir park inşa etmek için daha fazla vergi parası istediğini düşünün. Yerel bir işletme, Noel ikramiyeleri verebilmek için daha az vergi ödemek istiyor. İşletme sahibi "kötü" değil, aslında Noel ikramiyeleri vermek istiyor! Belediye meclisi de "kötü" değil, sadece çocuklar için bir park istiyorlar. Bazen hedefler uzlaşmaz bir şekilde çatışır. Gerçek dünya böyledir. Bu tür bir olay örgüsü, iki boyutlu "iyiye karşı kötü" sabah çizgi filminden çok daha fazla düşünceye yol açar.

I'd never heard of anycast until a few seconds ago when I read "What are some cool or useful server/networking tricks?". The wikipedia "Anycast" article on it is quite formal and doesn't really evoke a mental picture of how it would be used. Can someone explain in a few informal sentences what "anycast" is, how you configure it (just in a general sense), and what its benefits are (what does it make easier)?

Birkaç saniye önce "Bazı havalı veya kullanışlı sunucu/ağ hileleri nelerdir?" başlıklı bir yazı okurken anycast'i duymuştum. Vikipedi'deki "Anycast" makalesi oldukça resmi ve nasıl kullanılacağına dair zihinsel bir resim çizmiyor. Birisi birkaç cümleyle "anycast"in ne olduğunu, nasıl yapılandırıldığını (genel anlamda) ve faydalarının neler olduğunu (neleri kolaylaştırır?) açıklayabilir mi?

Anycast is networking technique where the same IP prefix is advertised from multiple locations. The network then decides which location to route a user request to, based on routing protocol costs and possibly the 'health' of the advertising servers. There are several benefits to anycast. First, in steady state, users of an anycast service (DNS is an excellent example) will always connect to the 'closest' (from a routing protocol perspective) DNS server. This reduces latency, as well as providing a level of load-balancing (assuming that your consumers are evenly distributed around your network). Another advantage is ease of configuration management. Rather than having to configure different DNS servers depending on where a server/workstation is deployed (Asia, America, Europe), you have one IP address that is configured in every location. Depending on how anycast is implemented, it can also provide a level of high availability. If the advertisement of the anycast route is conditional on some sort of health check (e.g. a DNS query for a well known domain, in this example), then as soon as a server fails its route can be removed. Once the network reconverges, user requests will be seamlessly forwarded to the next closest instance of DNS, without the need for any manual intervention or reconfiguration. A final advantage is that of horizontal scaling; if you find that one server is being overly loaded, simply deploy another one in a location that would allow it to take some proportion of the overloaded server's requests. Again, as no client configuration is required, this can be done very quickly.

Anycast, aynı IP önekinin birden fazla konumdan duyurulduğu bir ağ tekniğidir. Ağ daha sonra, yönlendirme protokolü maliyetlerine ve muhtemelen reklam sunucularının "sağlığına" dayanarak bir kullanıcı isteğini hangi konuma yönlendireceğine karar verir. Anycast'in birkaç avantajı vardır. Birincisi, sabit durumda, bir anycast hizmetinin kullanıcıları (DNS mükemmel bir örnektir) her zaman "en yakın" (bir yönlendirme protokolü perspektifinden) DNS sunucusuna bağlanacaktır. Bu, gecikmeyi azaltır ve bir düzeyde yük dengelemesi sağlar (tüketicilerinizin ağınızda eşit olarak dağıldığını varsayarak). Bir diğer avantajı da yapılandırma yönetiminin kolay olmasıdır. Bir sunucu/iş istasyonunun nerede konuşlandırıldığına (Asya, Amerika, Avrupa) bağlı olarak farklı DNS sunucuları yapılandırmak yerine, her konumda yapılandırılmış tek bir IP adresiniz olur. Anycast nasıl uygulandığına bağlı olarak, bir düzeyde yüksek kullanılabilirlik de sağlayabilir. Anycast yolunun duyurusu bir tür sağlık kontrolüne bağlıysa (örneğin, bu örnekte iyi bilinen bir alan adı için bir DNS sorgusu), bir sunucu arızalandığında yolu kaldırılabilir. Ağ yeniden birleştiğinde, kullanıcı istekleri, herhangi bir manuel müdahale veya yeniden yapılandırmaya gerek kalmadan, DNS'nin bir sonraki en yakın örneğine sorunsuz bir şekilde yönlendirilecektir. Son bir avantaj da yatay ölçeklendirmedir; bir sunucunun aşırı yüklendiğini tespit ederseniz, aşırı yüklenmiş sunucunun isteklerinin bir kısmını alabilecek bir konuma başka bir sunucu konuşlandırmanız yeterlidir. Yine, herhangi bir istemci yapılandırması gerekmediğinden, bu çok hızlı bir şekilde yapılabilir.

$A$ and $B$ are $n \times n$ matrices and $v$ is a vector with $n$ elements. $Av$ has $\approx 2n^2$ flops and $A+B$ has $n^2$ flops. Following this logic, $(A+B)v$ should be faster than $Av+Bv$. Yet, when I run the following code in matlab ```A = rand(2000,2000); B = rand(2000,2000); v = rand(2000,1); tic D=zeros(size(A)); D = A; for i =1:100 D = A + B; (D)*v; end toc tic for i =1:100 (A*v+B*v); end toc ``` The opposite is true. Av+Bv is over twice as fast. Any explanations?

$A$ ve $B$, $n \times n$ matrislerdir ve $v$, $n$ elemanlı bir vektördür. $Av$ yaklaşık olarak $2n^2$ flops'a ve $A+B$ ise $n^2$ flops'a sahiptir. Bu mantığı takip ederek, $(A+B)v$, $Av+Bv$'den daha hızlı olmalıdır. Yine de, matlab'da aşağıdaki kodu çalıştırdığımda ```A = rand(2000,2000); B = rand(2000,2000); v = rand(2000,1); tic D=zeros(size(A)); D = A; for i =1:100 D = A + B; (D)*v; end toc tic for i =1:100 (A*v+B*v); end toc ``` Tam tersi doğrudur. Av+Bv, iki katından fazla daha hızlıdır. Herhangi bir açıklama?

Except for code which does a significant number of floating-point operations on data that are held in cache, most floating-point intensive code is performance limited by memory bandwidth and cache capacity rather than by flops. $v$ and the products $Av$ and $Bv$ are all vectors of length 2000 (16K bytes in double precision), which will easily fit into a level 1 cache. The matrices $A$ and $B$ are 2000 by 2000 or about 32 megabytes in size. Your level 3 cache might be large enough to store one of these matrices if you've got a really good processor. Computing $Av$ requires reading 32 megabytes (for $A$) in from memory, reading in 16K bytes (for $v$) storing intermediate results in the L1 cache and eventually writing 16K bytes out to memory. Multiplying $Bv$ takes the same amount of work. Adding the two intermediate results to get the final result requires a trivial amount of work. That's a total of roughly 64 megabytes of reads and an insignificant number of writes. Computing $(A+B)$ requires reading 32 megabytes (for A) plus 32 megabytes (for B) from memory and writing 32 megabytes (for A+B) out. Then you have to do a single matrix-vector multiplication as above which involves reading 32 megabytes from memory (if you've got a big L3 cache, then perhaps this 32 megabytes is in that L3 cache.) That's a total of 96 megabytes of reads and 32 megabytes of writes. Thus there's twice as much memory traffic involved in computing this as $(A+B)v$ instead of $Av+Bv$. Note that if you have to do many of these multiplications with different vectors $v$ but the same $A$ and $B$, then it will become more efficient to compute $A+B$ once and reuse that matrix for the matrix-vector multiplications.

Veriler üzerinde önemli sayıda kayan nokta işlemi yapan kodlar hariç, çoğu kayan nokta yoğun kodu, flops yerine bellek bant genişliği ve önbellek kapasitesi ile performans açısından sınırlıdır. $v$ ve $Av$ ve $Bv$ çarpımları, 2000 uzunluğunda vektörlerdir (çift hassasiyette 16K bayt), bu da kolayca 1. seviye önbelleğe sığar. $A$ ve $B$ matrisleri 2000 x 2000 veya yaklaşık 32 megabayt boyutundadır. Gerçekten iyi bir işlemciniz varsa, 3. seviye önbelleğiniz bu matrislerden birini depolamak için yeterince büyük olabilir. $Av$ hesaplaması, bellekten 32 megabayt (A için) okumayı, 16K bayt (v için) okumayı, ara sonuçları L1 önbelleğinde saklamayı ve sonunda 16K bayt belleğe yazmayı gerektirir. $Bv$ çarpımı aynı miktarda iş gerektirir. Sonucu elde etmek için iki ara sonucu eklemek önemsiz miktarda iş gerektirir. Bu, yaklaşık 64 megabayt okuma ve önemsiz sayıda yazma işlemidir. $(A+B)$ hesaplaması, bellekten 32 megabayt (A için) artı 32 megabayt (B için) okumayı ve 32 megabayt (A+B için) yazmayı gerektirir. Ardından, yukarıda olduğu gibi, bellekten 32 megabayt okumayı içeren tek bir matris-vektör çarpımı yapmanız gerekir (büyük bir L3 önbelleğiniz varsa, o zaman belki bu 32 megabayt o L3 önbelleğindedir). Bu, toplam 96 megabayt okuma ve 32 megabayt yazma işlemidir. Bu nedenle, $Av+Bv$ yerine $(A+B)v$ hesaplamasında iki kat daha fazla bellek trafiği söz konusudur. Farklı $v$ vektörleri ancak aynı $A$ ve $B$ ile bu çarpımlardan birçoğunu yapmanız gerekiyorsa, $A+B$ bir kez hesaplamak ve bu matrisi matris-vektör çarpımları için yeniden kullanmak daha verimli hale gelecektir.

I came across a piece of code ```void *p = &&abc;```. What is the significance of ```&&``` here? I know about rvalue references but I think ```&&``` used in this context is different. What does ```&&``` indicate in ```void *p = &&abc;``` ?

```void *p = &&abc;``` kod parçasına rastladım. Burada ```&&```'nin önemi nedir? Sahiplik referanslarını biliyorum ama bu bağlamda kullanılan ```&&```'nin farklı olduğunu düşünüyorum. ```void *p = &&abc;```'de ```&&``` neyi gösterir?

## How to find it out That's the address of a label and it's a feature specific to GCC. ```int main(void) { void* startp; s: startp = &&s; printf(&quot;the assignment above starts at address %p\n&quot;, startp); return 0; } ``` You could have figured it out yourself by testing: ```int main(void) { void* startp; int a; startp = &&a; printf(&quot;startp=%p\n&quot;, startp); return 0; } ``` In which case GCC says: > error: label ‘a’ used but not defined ## Under the hood - assembly You need to know assembler to really understand this, but I'll try to explain you what an address of a label means. After the OS loads the .exe file from the disk, a component of the operating system called &quot;the loader&quot; (windows has the &quot;PE Loader&quot;, linux has &quot;ELF loader&quot; or maybe even others, if they're compiled in the kernel), it does a &quot;virtualization&quot; of that program, turning it into a process. This process thinks it is the only one in RAM and it has access to the entire RAM (that is, 0x00000000-0xFFFFFFFF on a 32-bit machine). (the above is just a short overwiew of what's happenning, you really need to learn assembly to understand it fully, so bear with me) Now, the label in a source code is basically an address. &quot;goto label;&quot; does nothing else than a jump to that address (think about the instruction pointer in assembly). This label stores this RAM address, and that's how you can find out that address. After you've learned ASM, you'll realize that that address points to a instruction within the ```.text``` section of the executable. The ```.text``` section is the one which holds you program's (binary) code to be executed. You can inspect this with: ``` objdump -x a.out ```

## Nasıl öğrenilir Bu bir etiketin adresidir ve GCC'ye özgü bir özelliktir. ```int main(void) { void* startp; s: startp = &&s; printf(&quot;the assignment above starts at address %p\n&quot;, startp); return 0; } ``` Test ederek kendiniz de bulabilirsiniz: ```int main(void) { void* startp; int a; startp = &&a; printf(&quot;startp=%p\n&quot;, startp); return 0; } ``` Bu durumda GCC şöyle der: > hata: 'a' etiketi kullanıldı ancak tanımlanmadı ## Perde arkası - derleme Bunu gerçekten anlamak için derleyici bilmeniz gerekir ancak bir etiketin adresinin ne anlama geldiğini açıklamaya çalışacağım. İşletim sistemi .exe dosyasını diskten yükledikten sonra, işletim sisteminin &quot;yükleyici&quot; adlı bir bileşeni (Windows'ta &quot;PE Yükleyici&quot;, Linux'ta &quot;ELF yükleyici&quot; veya hatta çekirdekte derlenmişlerse başka bileşenler vardır) bu programın &quot;sanallaştırılmasını&quot; yaparak onu bir işleme dönüştürür. Bu işlem RAM'deki tek işlem olduğunu düşünür ve tüm RAM'e erişebilir (yani 32 bitlik bir makinede 0x00000000-0xFFFFFFFF). (yukarıdakiler olan bitenin sadece kısa bir özetidir, bunu tam olarak anlamak için gerçekten derleyici öğrenmeniz gerekir, bu yüzden sabırlı olun) Şimdi, kaynak kodundaki etiket temelde bir adrestir. &quot;goto label;&quot; bu adrese atlamaktan başka bir şey yapmaz (derlemedeki talimat işaretçisini düşünün). Bu etiket bu RAM adresini depolar ve bu şekilde bu adresi bulabilirsiniz. ASM'yi öğrendikten sonra bu adresin yürütülebilir dosyanın ```.text``` bölümündeki bir talimata işaret ettiğini fark edeceksiniz. ```.text``` bölümü, yürütülecek programınızın (ikili) kodunu tutan bölümdür. Bunu şu şekilde inceleyebilirsiniz: ``` objdump -x a.out ```

When I execute "```python```" from the terminal with no arguments it brings up the Python interactive shell. When I execute "```cat | python```" from the terminal it doesn't launch the interactive mode. Somehow, without getting any input, it has detected that it is connected to a pipe. How would I do a similar detection in C or C++ or Qt?

"```python```" komutunu terminalden argüman olmadan çalıştırdığımda Python etkileşimli kabuğunu açıyor. "```cat | python```" komutunu terminalden çalıştırdığımda etkileşimli modu başlatmıyor. Bir şekilde, herhangi bir girdi almadan, bir boruya bağlı olduğunu tespit etmiş. Benzer bir tespiti C veya C++ veya Qt'de nasıl yapabilirim?

You can use ```isatty```: ``` #include <stdio.h> #include <io.h> ... if (isatty(fileno(stdin))) printf( "stdin is a terminal\n" ); else printf( "stdin is a file or a pipe\n"); ``` On windows they're prefixed with underscores: ```_isatty```, ```_fileno```.

```isatty``` kullanabilirsiniz: ``` #include <stdio.h> #include <io.h> ... if (isatty(fileno(stdin))) printf( "stdin bir terminaldir\n" ); else printf( "stdin bir dosya veya borudur\n"); ``` Windows'ta bunlar alt çizgilerle öne eklenir: ```_isatty```, ```_fileno```.

"The video of Pythom Space's first rocket test has raised a few eyebrows The video prompted hundreds of replies on Twitter, including some from rather horrified rocket scientists. &quot;We knew better as untrained college students,&quot; said Jordan Noone, the co-founder of Relativity Space. Pythom “Micro jump” What exactly did they get wrong with this test? Note: The Pythom Space CEO did eventually respond to the original Ars Technica story linked above. It does offer their own take on some of the issues raised there and elsewhere (including some of the points in the answer below)"

"Pythom Space'in ilk roket testinin videosu bazı kaşları kaldırdı Video, Twitter'da yüzlerce yanıta neden oldu, bunlardan bazıları da dehşete düşmüş roket bilimcilerindendi. Relativity Space'in kurucu ortağı Jordan Noone, "Eğitimsiz üniversite öğrencileri olarak daha iyisini biliyorduk" dedi. Pythom "Mikro sıçrama" Bu testte tam olarak neyi yanlış yaptılar? Not: Pythom Space CEO'su sonunda yukarıda bağlantısı verilen orijinal Ars Technica haberine yanıt verdi. Orada ve başka yerlerde gündeme getirilen bazı konular (aşağıdaki yanıttaki bazı noktalar da dahil) hakkında kendi görüşlerini sunuyor"

The easy-to-spot stuff: * (assumed) Improper transportation of hazardous materials. Both white fuming nitric acid and furfuryl alcohol are considered hazardous materials; none of the vehicles in the video appears to have a hazmat placard, the rocket is not an approved hazmat container, and the fuel containers seen in other videos are emphatically not approved. * No personal protective gear. Nitric acid and furfurly alcohol are both toxic, and heavy loads are being lifted. Nobody is seen wearing any sort of protective gear, not even hard hats or safety glasses. * Insecure rigging when lifting the test object upright. A strap, particularly one being pulled at a sharp angle, is far less safe than a proper lifting point. * Bad angle when lifting the test object upright. This puts excess loads on things, increasing the risk of a fall or failure. * Using unbraced legs as a pivot point when lifting the test object upright. You can see they're on the verge of buckling. * (assumed) Lifting the test object while already fueled. In the event of a fall, this ensures an explosion if the tanks rupture, as the fuels are hypergolic. * Having people stand under a suspended load. If the test object falls, this will cause serious injury or death to at least two people. * Using a truck to pull the lifting cable. This provides far less control than a proper winch. * Having personnel in the blast area of the test object. In the event of an failure, this makes it highly likely that they will be engulfed in the fireball, struck by debris, or poisoned by fuel vapors. * Having personnel in the exhaust area of the test object. Even during normal operation, they will be exposed to nitric acid, furfuryl alcohol, and assorted nitrogen oxides, all of which are highly toxic. * Having unnecessary equipment in the test area. In the event of a failure, this can become additional flying debris. * Not properly securing the test object. In the event of higher-than-expected performance, this will become self-propelled debris; in the event of a premature shutdown, the resulting hop-and-crash will rupture the fuel tanks and cause an explosion. * Not providing a flight termination system. In the event that the test object becomes airborne, they have no way of keeping it from leaving the test area. * (assumed) Insufficient fire-extinguishing equipment on site. None of the area views show a pumper truck or other equipment capable of dealing with a brush fire ignited by 15+ kg of hypergolic fuels. * Improper fire-extinguishing equipment. At one point, you can see what appears to be an ordinary dry-chemical fire extinguisher. This should not be used when dealing with nitric acid. * Oxidizer-rich shutdown. You can see see the reddish cloud of nitric-acid byproducts at the end of the burn; this is likely the result of the oxidizer reacting with the engine. * (assumed) No post-burn decontamination of the area. The celebratory post-burn shot shows no sign of cleanup. Combined with the oxidizer-rich shutdown, this means they're likely walking through an area contaminated with nitric acid.

Kolayca fark edilebilecek şeyler: * (varsayılan) Tehlikeli maddelerin uygunsuz taşınması. Hem beyaz dumanlı nitrik asit hem de furfuril alkol tehlikeli maddeler olarak kabul edilir; videodaki araçların hiçbirinde tehlikeli madde plakası görünmüyor, roket onaylı bir tehlikeli madde konteyneri değil ve diğer videolarda görülen yakıt konteynerleri kesinlikle onaylı değil. * Kişisel koruyucu ekipman yok. Nitrik asit ve furfuril alkolün her ikisi de toksiktir ve ağır yükler kaldırılmaktadır. Hiç kimsenin koruyucu ekipman giydiği görülmüyor, hatta kask veya emniyet gözlüğü bile yok. * Test nesnesini dik konuma kaldırırken güvenli olmayan donanım. Özellikle keskin bir açıyla çekilen bir kayış, uygun bir kaldırma noktasından çok daha az güvenlidir. * Test nesnesini dik konuma kaldırırken kötü açı. Bu, şeylere aşırı yük bindirir ve düşme veya arıza riskini artırır. * Test nesnesini dik konuma kaldırırken desteksiz bacakları bir pivot noktası olarak kullanmak. Çökmek üzere olduklarını görebilirsiniz. * (varsayılan) Test nesnesi zaten yakıtlıyken kaldırmak. Bir düşme durumunda, yakıtlar hipergolik olduğundan tanklar yırtılırsa bu bir patlama sağlar. * İnsanların askıya alınmış bir yükün altında durması. Test nesnesi düşerse, bu en az iki kişi için ciddi yaralanmalara veya ölüme neden olur. * Kaldırma kablosunu çekmek için bir kamyon kullanmak. Bu, uygun bir vinçten çok daha az kontrol sağlar. * Personelin test nesnesinin patlama alanında olması. Bir arıza durumunda, bu onların ateş topuna kapılma, enkaz tarafından vurulma veya yakıt buharları tarafından zehirlenme olasılığını çok yüksek hale getirir. * Personelin test nesnesinin egzoz alanında olması. Normal çalışma sırasında bile nitrik aside, furfuril alkole ve hepsi son derece toksik olan çeşitli azot oksitlere maruz kalacaklardır. * Test alanında gereksiz ekipman bulundurmak. Bir arıza durumunda, bu ek uçan enkaz haline gelebilir. * Test nesnesini düzgün bir şekilde sabitlememek. Beklenenden daha yüksek performans durumunda, bu kendiliğinden hareket eden enkaz haline gelecektir; erken bir kapanma durumunda, ortaya çıkan zıplama ve çarpma yakıt tanklarını yırtıp bir patlamaya neden olacaktır. * Bir uçuş sonlandırma sistemi sağlamamak. Test nesnesinin havaya fırlaması durumunda, onu test alanından çıkmasını engellemenin bir yolu yoktur. * (varsayılan) Sahada yetersiz yangın söndürme ekipmanı. Bölge görünümlerinin hiçbirinde 15 kg'dan fazla hipergolik yakıtın tutuşturduğu bir yangını söndürebilecek bir itfaiye aracı veya başka bir ekipman gösterilmiyor. * Uygunsuz yangın söndürme ekipmanı. Bir noktada, sıradan bir kuru kimyasal yangın söndürücü gibi görünen bir şey görebilirsiniz. Bu, nitrik asitle uğraşırken kullanılmamalıdır. * Oksitleyici açısından zengin kapanma. Yanmanın sonunda nitrik asit yan ürünlerinin kırmızımsı bulutunu görebilirsiniz; bu muhtemelen oksitleyicinin motorla reaksiyona girmesinin sonucudur. * (varsayılan) Yanma sonrası alanın dekontaminasyonu yok. Yanma sonrası kutlama çekimi, temizlik belirtisi göstermiyor. Oksitleyici açısından zengin kapanma ile birleştiğinde, bunun nitrik asitle kirlenmiş bir alanda yürüdükleri anlamına gelir.

When should I use wp_register_script() with wp_enqueue_script() vs just wp_enqueue_script()?

wp_register_script() ile wp_enqueue_script()'i ne zaman kullanmalıyım, yoksa sadece wp_enqueue_script()?

The ```wp_register_script()``` Codex page literally says: A safe way of registering javascripts in WordPress for later use with ```wp_enqueue_script()```. This means, if you want to register your scripts, but not directly load them in your pages, you can register the files once, and then load them when you need them. For example: You have a switch statement wich loads some functionality, but two of three cases needs a particular javascript file, and one doesn't. You can enqueue the script every time, wich costs more resources, or just enqueue the script when you need it: ```... wp_register_script( 'my-handy-javascript', ... ); ... switch( $somevar ) { case 'value': wp_enqueue_script( 'my-handy-javascript' ); // needs the file ... break; case 'value2': wp_enqueue_script( 'my-handy-javascript' ); // needs the file ... break; default: case 'value3': // doesn't needs the file ... break; } ``` It is not necessary to register a script and then enqueue them, but it can provide some logic in your code if you register all the scripts you need somewhere in your ```functions.php``` instead of everywhere in your code. The Codex also tells the following: Use the ```wp_enqueue_scripts``` action to call this function, or ```admin_enqueue_scripts``` to call it on the admin side. This means that if you want to enqueue your script on the frond-end and in the back-end, you can register a script once, and then load it on the front-end with ```wp_enqueue_script``` and in the back-end with ```admin_enqueue_script```. This way you won't have the same enqueue recourse twice in one theme, plugin, widget or whatever.

```wp_register_script()``` Codex sayfası tam olarak şöyle diyor: WordPress'te daha sonra ```wp_enqueue_script()``` ile kullanılmak üzere javascript'leri kaydetmenin güvenli bir yolu. Bu, komut dosyalarınızı kaydetmek ancak sayfalarınıza doğrudan yüklemek istemiyorsanız, dosyaları bir kez kaydedebilir ve ardından ihtiyaç duyduğunuzda yükleyebilirsiniz. Örneğin: Bazı işlevleri yükleyen bir switch ifadeniz var, ancak üç durumdan ikisi belirli bir javascript dosyasına ihtiyaç duyuyor, biri ise ihtiyaç duymuyor. Komut dosyasını her seferinde sıraya koyabilirsiniz, bu da daha fazla kaynak harcar veya komut dosyasını yalnızca ihtiyacınız olduğunda sıraya koyabilirsiniz: ```... wp_register_script( 'my-handy-javascript', ... ); ... switch( $somevar ) { case 'value': wp_enqueue_script( 'my-handy-javascript' ); // dosyaya ihtiyaç duyar ... break; case 'value2': wp_enqueue_script( 'my-handy-javascript' ); // dosyaya ihtiyaç duyar ... break; default: case 'value3': // dosyaya ihtiyaç duymaz ... break; } ``` Bir komut dosyasını kaydetmek ve ardından sıraya koymak gerekli değildir, ancak tüm ihtiyaç duyduğunuz komut dosyalarını kodunuzun her yerine değil, ```functions.php``` dosyanızın bir yerine kaydederseniz kodunuzda biraz mantık sağlayabilir. Codex ayrıca şunları da söyler: Bu işlevi çağırmak için ```wp_enqueue_scripts``` eylemini veya yönetici tarafında çağırmak için ```admin_enqueue_scripts``` eylemini kullanın. Bu, komut dosyanızı ön uçta ve arka uçta sıraya koymak istiyorsanız, bir komut dosyasını bir kez kaydedebilir ve ardından ön uçta ```wp_enqueue_script``` ile ve arka uçta ```admin_enqueue_script``` ile yükleyebilirsiniz. Bu şekilde, aynı sıraya koyma kaynağını bir tema, eklenti, widget veya başka bir şeyde iki kez kullanmamış olursunuz.

When encoding a logic into a proof assistant such as Coq or Isabelle, a choice needs to be made between using a shallow and a deep embedding. In a shallow embedding logical formulas are written directly in the logic of the theorem prover, whereas in a deep embedding logical formulas are represented as a datatype. * What are the advantages and limitations of the various approaches? * Are there any guidelines available for determining which to use? * Is it possible to switch between the two representations in any systematic fashion? As motivation, I would like to encode various security related logics into Coq and am wondering what the pros and cons of the different approaches are.

Coq veya Isabelle gibi bir kanıt asistanına bir mantığı kodlarken, sığ ve derin yerleştirme kullanımı arasında bir seçim yapılması gerekir. Sığ bir yerleştirmede mantıksal formüller doğrudan teorem kanıtlayıcısının mantığına yazılırken, derin bir yerleştirmede mantıksal formüller bir veri tipi olarak temsil edilir. * Çeşitli yaklaşımların avantajları ve sınırlamaları nelerdir? * Hangisinin kullanılacağını belirlemek için herhangi bir kılavuz mevcut mu? * İki gösterim arasında sistematik bir şekilde geçiş yapmak mümkün mü? Motivasyon olarak, çeşitli güvenlikle ilgili mantıkları Coq'a kodlamak istiyorum ve farklı yaklaşımların artılarını ve eksilerini merak ediyorum.

> What are the advantages and limitations of the various approaches? * Pros of deep embeddings : You can prove and define things by induction on formulas' structure. Examples of interests are the size of a formula. * Cons of deep embeddings: You have do deal explicitly with binding of variables. That's usually very laborious. > Are there any guidelines available for determining which to use ? Shallow embeddings are very useful to import result proved in the object logic. For instance, if you have prove something in a small logic (e.g. separation logic) shallow embeddings can be a tool of choice to import your result in Coq. On the other side, deep embedding are almost mandatory when you want to prove meta-theorems about the object logic (like cut-elimination for instance). > Is it possible to switch between the two representations in any systematic fashion? The idea behind the shallow embedding is really to work directly in a model of the object formulas. Usually people will maps an object formula P directly (using notations or by doing the translation by hand) to an inhabitant of Prop. Of course, there are inhabitants of Prop which cannot be obtained by embedding a formula of the object logic. Therefore you lose some kind of completeness. So it is possible to send every result obtained in a deep embedding setting through an interpretation function. Here is a little coq example: ``` Inductive formula : Set := Ftrue : formula | Ffalse : formula | Fand : formula -> formula -> formula | For : formula -> formula -> formula. Fixpoint interpret (F : formula) : Prop := match F with Ftrue => True | Ffalse => False | Fand a b => (interpret a) /\ (interpret b) | For a b => (interpret a) \/ (interpret b) end. Inductive derivable : formula -> Prop := deep_axiom : derivable Ftrue | deep_and : forall a b, derivable a -> derivable b -> derivable (Fand a b) | deep_or1 : forall a b, derivable a -> derivable (For a b) | deep_or2 : forall a b, derivable b -> derivable (For a b). Inductive sderivable : Prop -> Prop := shallow_axiom : sderivable True | shallow_and : forall a b, sderivable a -> sderivable b -> sderivable (a /\ b) | shallow_or1 : forall a b, sderivable a -> sderivable (a \/ b) | shallow_or2 : forall a b, sderivable b -> sderivable (a \/ b). (* You can prove the following lemma: *) Lemma shallow_deep : forall F, derivable F -> sderivable (interpret F). (* You can NOT prove the following lemma :*) Lemma t : forall P, sderivable P -> exists F, interpret F = P. ```

> Çeşitli yaklaşımların avantajları ve sınırlamaları nelerdir? * Derin gömmelerin artıları: Formüllerin yapısı üzerinde tümevarımla şeyleri kanıtlayabilir ve tanımlayabilirsiniz. İlgi çeken örnekler bir formülün büyüklüğüdür. * Derin gömmelerin eksileri: Değişkenlerin bağlanmasıyla açıkça ilgilenmeniz gerekir. Bu genellikle çok zahmetlidir. > Hangisinin kullanılacağına karar vermek için mevcut herhangi bir kılavuz var mı? Sığ gömmeler, nesne mantığında kanıtlanmış sonuçları içe aktarmak için çok kullanışlıdır. Örneğin, küçük bir mantıkta (ör. ayırma mantığı) bir şeyi kanıtladıysanız, sığ gömmeler sonucunuzu Coq'a aktarmak için bir seçim aracı olabilir. Öte yandan, nesne mantığı hakkında meta teoremler kanıtlamak istediğinizde (örneğin kesme elemesi gibi) derin gömmeler neredeyse zorunludur. > İki gösterim arasında sistematik bir şekilde geçiş yapmak mümkün müdür? Sığ gömmelerin ardındaki fikir, gerçekten nesne formüllerinin bir modelinde doğrudan çalışmaktır. Genellikle insanlar bir nesne formülü P'yi doğrudan (notasyonları kullanarak veya çeviriyi elle yaparak) Prop'un bir sakinine eşler. Elbette, nesne mantığının bir formülünü gömerek elde edilemeyen Prop sakinleri vardır. Bu nedenle bir tür bütünlüğü kaybedersiniz. Bu nedenle, derin bir gömme ayarında elde edilen her sonucu bir yorumlama işlevi aracılığıyla göndermek mümkündür. İşte küçük bir coq örneği: ``` Inductive formula : Set := Ftrue : formula | Ffalse : formula | Fand : formula -> formula -> formula | For : formula -> formula -> formula. Fixpoint interpret (F : formula) : Prop := match F with Ftrue => True | Ffalse => False | Fand a b => (interpret a) /\ (interpret b) | For a b => (interpret a) \/ (interpret b) end. Inductive derivable : formula -> Prop := deep_axiom : derivable Ftrue | deep_and : forall a b, derivable a -> derivable b -> derivable (Fand a b) | deep_or1 : forall a b, derivable a -> derivable (For a b) | deep_or2 : forall a b, derivable b -> derivable (For a b). Inductive sderivable : Prop -> Prop := shallow_axiom : sderivable True | shallow_and : forall a b, sderivable a -> sderivable b -> sderivable (a /\ b) | shallow_or1 : forall a b, sderivable a -> sderivable (a \/ b) | shallow_or2 : forall a b, sderivable b -> sderivable (a \/ b). (* Aşağıdaki lemma'yı kanıtlayabilirsiniz: *) Lemma shallow_deep : forall F, derivable F -> sderivable (interpret F). (* Aşağıdaki lemma'yı kanıtlayamazsınız: *) Lemma t : forall P, sderivable P -> exists F, interpret F = P. ```

Prove that the union of countably many countable sets is countable.

Sayılabilir çok sayıda sayılabilir kümenin birleşiminin sayılabilir olduğunu kanıtlayın.

Let's start with a quick review of "countable". A set is countable if we can set up a 1-1 correspondence between the set and the natural numbers. As an example, let's take $\mathbb{Z}$, which consists of all the integers. Is $\mathbb Z$ countable? It may seem uncountable if you pick a naive correspondence, say $1 \mapsto 1$, $2 \mapsto 2 ...$, which leaves all of the negative numbers unmapped. But if we organize the integers like this: $$0$$ $$1, -1$$ $$2, -2$$ $$3, -3$$ $$...$$ We quickly see that there is a map that works. Map 1 to 0, 2 to 1, 3 to -1, 4 to 2, 5 to -2, etc. So given an element $x$ in $\mathbb Z$, we either have that $1 \mapsto x$ if $x=0$, $2x \mapsto x$ if $x > 0$, or $2|x|+1 \mapsto x$ if $x . So the integers are countable. We proved this by finding a map between the integers and the natural numbers. So to show that the union of countably many sets is countable, we need to find a similar mapping. First, let's unpack "the union of countably many countable sets is countable": 1. "countable sets" pretty simple. If $S$ is in our set of sets, there's a 1-1 correspondence between elements of $S$ and $\mathbb N$. 2. "countably many countable sets" we have a 1-1 correspondence between $\mathbb N$ and the sets themselves. In other words, we can write the sets as $S_1$, $S_2$, $S_3$... Let's call the set of sets $\{S_n\}, n \in \mathbb N$. 3. "union of countably many countable sets is countable". There is a 1-1 mapping between the elements in $\mathbb N$ and the elements in $S_1 \cup S_2 \cup S_3 ...$ So how do we prove this? We need to find a correspondence, of course. Fortunately, there's a simple way to do this. Let $s_{nm}$ be the $mth$ element of $S_n$. We can do this because $S_n$ is by definition of the problem countable. We can write the elements of ALL the sets like this: $$s_{11}, s_{12}, s_{13} ...$$ $$s_{21}, s_{22}, s_{23} ...$$ $$s_{31}, s_{32}, s_{33} ...$$ $$...$$ Now let $1 \mapsto s_{11}$, $2 \mapsto s_{12}$, $3 \mapsto s_{21}$, $4 \mapsto s_{13}$, etc. You might notice that if we cross out every element that we've mapped, we're crossing them out in diagonal lines. With $1$ we cross out the first diagonal, $2-3$ we cross out the second diagonal, $4-6$ the third diagonal, $7-10$ the fourth diagonal, etc. The $nth$ diagonal requires us to map $n$ elements to cross it out. Since we never "run out" of elements in $\mathbb N$, eventually given any diagonal we'll create a map to every element in it. Since obviously every element in $S_1 \cup S_2 \cup S_3 ...$ is in one of the diagonals, we've created a 1-1 map between $\mathbb N$ and the set of sets. Let's extend this one step further. What if we made $s_{11} = 1/1$, $s_{12} = 1/2$, $s_{21} = 2/1$, etc? Then $S_1 \cup S_2 \cup S_3 ... = \mathbb Q^+$! This is how you prove that the rationals are countable. Well, the positive rationals anyway. Can you extend these proofs to show that the rationals are countable?

"Sayılabilir"in hızlı bir gözden geçirmeyle başlayalım. Bir küme, küme ile doğal sayılar arasında 1-1 bir eşleşme kurabiliyorsak sayılabilirdir. Örnek olarak, tüm tam sayılardan oluşan $\mathbb{Z}$'yi alalım. $\mathbb Z$ sayılabilir mi? $1 \mapsto 1$, $2 \mapsto 2 ...$ gibi saf bir eşleşme seçerseniz sayılamaz gibi görünebilir, bu da tüm negatif sayıları eşlenmemiş bırakır. Ancak tam sayıları şu şekilde düzenlersek: $$0$$ $$1, -1$$ $$2, -2$$ $$3, -3$$ $$...$$ Hızlıca işe yarayan bir eşleşme olduğunu görürüz. 1'i 0'a, 2'yi 1'e, 3'ü -1'e, 4'ü 2'ye, 5'i -2'ye eşleyin, vb. Yani $\mathbb Z$'de bir $x$ elemanı verildiğinde, $x=0$ ise $1 \mapsto x$ olur, $x > 0$ ise $2x \mapsto x$ olur veya $x . So$ ise $2|x|+1 \mapsto x$ olur. Yani tam sayılar sayılabilir. Bunu, tam sayılar ile doğal sayılar arasında bir eşleşme bularak kanıtladık. Yani sayılabilir birçok kümenin birleşiminin sayılabilir olduğunu göstermek için benzer bir eşleşme bulmamız gerekiyor. Öncelikle, "sayılabilir birçok sayılabilir kümenin birleşimi sayılabilirdir" ifadesini açalım: 1. "sayılabilir kümeler" oldukça basit. $S$ kümeler kümemizde ise, $S$ elemanları ile $\mathbb N$ arasında 1-1 bir eşleşme vardır. 2. "sayılabilir birçok sayılabilir küme" $\mathbb N$ ile kümelerin kendileri arasında 1-1 bir eşleşme vardır. Başka bir deyişle, kümeleri $S_1$, $S_2$, $S_3$... olarak yazabiliriz. Kümeler kümesine $\{S_n\}, n \in \mathbb N$ diyelim. 3. "sayılabilir birçok sayılabilir kümenin birleşimi sayılabilirdir". $\mathbb N$'deki elemanlar ile $S_1 \cup S_2 \cup S_3 ...$'deki elemanlar arasında 1-1 bir eşleşme vardır. Peki bunu nasıl kanıtlarız? Elbette bir eşleşme bulmamız gerekiyor. Neyse ki bunu yapmanın basit bir yolu var. $s_{nm}$, $S_n$'nin $mth$ elemanı olsun. Bunu yapabiliriz çünkü $S_n$ tanım gereği sayılabilir. TÜM kümelerin elemanlarını şu şekilde yazabiliriz: $$s_{11}, s_{12}, s_{13} ...$$ $$s_{21}, s_{22}, s_{23} ...$$ $$s_{31}, s_{32}, s_{33} ...$$ $$...$$ Şimdi $1 \mapsto s_{11}$, $2 \mapsto s_{12}$, $3 \mapsto s_{21}$, $4 \mapsto s_{13}$, vb. eşleştirelim. Eşleştirdiğimiz her bir elemanı üzerini çizersek, onları çapraz çizgiler halinde çizdiğimizi fark edebilirsiniz. $1$ ile ilk çapraz çizgiyi, $2-3$ ile ikinci çapraz çizgiyi, $4-6$ ile üçüncü çapraz çizgiyi, $7-10$ ile dördüncü çapraz çizgiyi vb. çizeriz. $nth$ çapraz çizgi, onu çizmek için $n$ eleman eşleştirmemizi gerektirir. $\mathbb N$'de hiçbir zaman eleman "tükenmediğinden", sonunda herhangi bir çapraz çizgi verildiğinde içindeki her bir elemana bir eşleşme oluşturacağız. Açıkçası $S_1 \cup S_2 \cup S_3 ...$'deki her bir eleman çapraz çizgilerden birinde olduğundan, $\mathbb N$ ile kümeler kümesi arasında 1-1 bir eşleşme oluşturduk. Bunu bir adım daha ileriye taşıyalım. $s_{11} = 1/1$, $s_{12} = 1/2$, $s_{21} = 2/1$, vb. yaparsak ne olur? O zaman $S_1 \cup S_2 \cup S_3 ... = \mathbb Q^+$! Rasyonellerin sayılabilir olduğunu kanıtlamanın yolu budur. Neyse, pozitif rasyoneller her neyse. Bu kanıtları rasyonellerin sayılabilir olduğunu göstermek için genişletebilir misiniz?

Você encontra na internet a afirmação que Singletons são ruins. Isto é verdade? Por quê? O problema seria generalizado para quaisquer objetos com instância única? Ou para qualquer coisa que tenha estado global? Se é tão ruim, pra que foi inventado? Ou seja, que problema ele queria resolver? Quais os problemas que terei se usá-lo? Existe alternativa viável?

İnternette Singleton'ların kötü olduğu iddiasını görüyorsunuz. Bu doğru mu? Neden? Sorun, tek örnekli nesneler için mi yoksa genel olan her şey için mi geçerlidir? Bu kadar kötüyse, neden icat edildi? Yani hangi sorunu çözmek istiyordu? Kullanırsam hangi sorunlarla karşılaşırım? Uygun bir alternatif var mı?

Muito da polêmica ocorre pela falta de uma contextualização. Não vejo nada que desabone o padrão Sigleton quando usado no contexto correto. Sim, ele pode causar muito mal, assim como qualquer padrão de projeto aplicado indevidamente sem análise do impacto e dos efeitos colaterais. ###Porque não usar * Acoplamento. Ao usar um Singleton você está acoplando o código a uma implementação estática e específica. Isso torna o seu código dependente dessa classe e impede, por exemplo, criar mocks em testes unitários. Desse ponto de vista a consequência é basicamente a mesma de fazer diretamente um ```new MeuObjetoImportante()```, pois é uma dependência direta da classe. * Escopo. O padrão Singleton aplicado conforme a definição também elimina o conceito de escopo. Isso significa que se você por alguma razão decidir que para determinados componentes da aplicação você precisa de outra implementação terá que alterar manualmente todas as classes. * Não garantia de uma instância única. Em certos casos o padrão pode levar à falsa segurança de que existirá apenas uma instância. Vamos supor que você projete um sistema web e quer dar acesso a um arquivo ou recurso exclusivo. Um Singleton parece uma boa prática, não é? Mas e se amanhã você fizer o deploy da aplicação em um cluster com N servidores. No caso de Java isso também é bem complicado, pois não existe isso de uma classe por JVM. O conceito correto é uma classe por ```ClassLoader```, de forma que num mesmo servidor JEE duas aplicações diferentes podem ter, cada uma, sua própria versão de uma mesma classe. As variáveis estáticas não são compartilhadas entre essas versões da mesma classe, portanto o escopo do Singleton em Java é por ```ClassLoader``` e não por programa. ###Porque usar Em algumas situações você sabe que vai ter só uma instância da classe. Em uma aplicação Desktop, por exemplo, não há porque ter "frescuras" adicionais para obter uma conexão com o banco de dados. Também não vejo problemas em um objeto encapsulando alguns atributos de configuração globais. Simplesmente não valeria o esforço de implementar algum mecanismo muito elaborado para algo tão simples. ###Como usar Quando pensamos em Singleton, logo a implementação clássica do Gang of Four nos vêm à mente. Os tópicos anteriores desta resposta consideraram isso. Porém, com a ascensão do uso de frameworks de Inversão de Controle (IoC) e Injeção de Dependência (DI), existe hoje uma forma muito mais "segura" e flexível de implementar o padrão: deixe o framework cuidar disso para você! ###Como evitar o Singleton Apesar de implementações mais simples poderem usar o padrão Singleton da forma "clássica" sem problemas, em geral seria melhor aplicar a Inversão de Controle simplesmente deixar a instância de suas dependências serem injetadas. Dessa forma, caso amanhã os requisitos mudem e você preciso injetar diferentes instâncias, ou mesmo queira criar mocks de teste, basta configurar seu container ou framework para tal, sem alterar as implementações existentes.

Tartışmaların çoğu bağlam eksikliğinden kaynaklanıyor. Singleton kalıbının doğru bağlamda kullanıldığında itibarını zedeleyecek hiçbir şey görmüyorum. Evet, herhangi bir tasarım kalıbının etki ve yan etkileri analiz edilmeden yanlış uygulanması gibi, bu da çok fazla zarara neden olabilir. ###Kullanılmaması gereken durumlar * Bağlantı. Bir Singleton kullanırken, kodu statik ve özel bir uygulamaya bağlıyorsunuz. Bu, kodunuzu bu sınıfa bağımlı hale getirir ve örneğin birim testlerinde alaylar oluşturmayı engeller. Bu açıdan sonuç, doğrudan ```new MeuObjetoImportante()``` yapmakla temelde aynıdır, çünkü sınıfın doğrudan bir bağımlılığıdır. * Kapsam. Tanıma göre uygulanan Singleton kalıbı, kapsam kavramını da ortadan kaldırır. Yani, herhangi bir nedenle uygulamanın belirli bileşenleri için başka bir uygulamaya ihtiyacınız olduğuna karar verirseniz, tüm sınıfları manuel olarak değiştirmeniz gerekecektir. * Tek bir örneğin garantisi yok. Bazı durumlarda, kalıp yalnızca bir örneğin olacağı konusunda yanlış bir güvenliğe yol açabilir. Bir web sistemi tasarladığınızı ve özel bir dosyaya veya kaynağa erişim sağlamak istediğinizi varsayalım. Bir Singleton iyi bir uygulama gibi görünüyor, değil mi? Peki ya yarın uygulamayı N sunuculu bir kümede dağıtırsanız? Java durumunda bu da oldukça karmaşıktır, çünkü JVM başına bir sınıf diye bir şey yoktur. Doğru kavram ```ClassLoader``` başına bir sınıftır, böylece aynı JEE sunucusunda iki farklı uygulama, her biri aynı sınıfın kendi sürümüne sahip olabilir. Statik değişkenler, aynı sınıfın bu sürümleri arasında paylaşılmaz, bu nedenle Java'da Singleton'ın kapsamı programa göre değil ```ClassLoader```'a göredir. ###Kullanılması gereken durumlar Bazı durumlarda, sınıftan yalnızca bir örneğiniz olacağını bilirsiniz. Örneğin, bir Masaüstü uygulamasında, veritabanına bağlantı almak için ek "numaralara" gerek yoktur. Ayrıca, bazı genel yapılandırma özniteliklerini kapsayan bir nesnede de sorun görmüyorum. Bu kadar basit bir şey için çok ayrıntılı bir mekanizma uygulamaya koymak zahmete değmez. ###Kullanım şekli Singleton'ı düşündüğümüzde, Gang of Four'un klasik uygulaması hemen aklımıza geliyor. Bu cevabın önceki başlıkları bunu dikkate aldı. Ancak, Tersine Kontrol (IoC) ve Bağımlılık Enjeksiyonu (DI) çerçevelerinin kullanımının artmasıyla, kalıbı uygulamanın çok daha "güvenli" ve esnek bir yolu var: Çerçevenin bunu sizin için halletmesine izin verin! ###Singleton'dan kaçınma Daha basit uygulamalar Singleton kalıbını "klasik" şekilde sorunsuz bir şekilde kullanabilse de, genel olarak Tersine Kontrolü uygulamak ve bağımlılıklarınızın örneğinin enjekte edilmesine izin vermek daha iyi olacaktır. Bu şekilde, yarın gereksinimler değişirse ve farklı örnekler enjekte etmeniz gerekirse veya hatta test alayları oluşturmak isterseniz, mevcut uygulamaları değiştirmeden bunun için kapsayıcınızı veya çerçevenizi yapılandırmanız yeterlidir.

The construction of Solomon's temple includes a piece of furnishing described in 1 Kings 7:23 (ESV): Then he made the sea of cast metal. It was round, ten cubits from brim to brim, and five cubits high, and a line of thirty cubits measured its circumference. So if the ```diameter = 10``` cubits and the ```circumference = 30``` cubits, then ```π = 3``` by the equation ```C = π * D```. Of course, such an object does not exist since ```π = 3.14159...``` yet clearly the sea was constructed at some point. So how do we resolve this contradiction?

Süleyman'ın tapınağının inşası, 1. Krallar 7:23'te (ESV) anlatılan bir mobilya parçasını içerir: Sonra dökme metalden bir deniz yaptı. Kenardan kenara on arşın yuvarlak, beş arşın yüksekti ve çevresi otuz arşın ölçülüyordu. Yani ```çap = 10``` arşın ve ```çevre = 30``` arşın ise, ```C = π * D``` denklemine göre ```π = 3``` olur. Elbette, ```π = 3,14159...``` olduğundan böyle bir nesne yoktur, ancak denizin bir noktada inşa edildiği açıktır. Peki bu çelişkiyi nasıl çözeriz?

To start with, compare the circle the diameter we're given would make with the circle the circumference we're given would make: Since a circumference is π times the diameter, a 'pure' circle of 10 cubits in diameter as we describe the sea as having would be 10π cubits in circumference, or roughly 31.4 cubits. Now, since the circumference attributed to our sea is only 30 cubits, it represents a smaller circle, which is 30/π or roughly 9.55 cubits in diameter. Or to tabulate it: ```Circle A: ~9.55 cubits diameter, 30 cubits circumference Circle B: 10 cubits diameter, ~31.4 cubits circumference ``` Given that, we have two diameters differing by about .45 cubits (about eight inches on an 18-inch cubit--a sizable difference). Since we know the sea was a physical object and not a circle bounded by an infinitesimal line, we can safely understand that the sea must be of some thickness; on this ground, it would not be unreasonable to take the shorter dimension as the inner measurement, and the longer dimension as the outer measurement, and see where that takes us. Dividing the difference in the diameters in half, this would make the wall around our sea at least .225 cubits thick--i.e., about four inches on either end of the sea, assuming an eighteen-inch cubit. Do we have any authority for assuming that this is the case and saying the sea was anything like four inches thick? A couple of verses after this we have 1 Kings 7:26, which gives it to us outright: Its thickness was a handbreadth, and its brim was made like the brim of a cup, like the flower of a lily. It held two thousand baths. A handbreadth as a unit of measurement is generally given as between three and four inches. (The 'Number Pi in the Bible' site linked elsewhere gives as its rebuttal to this sort of argument the statement "The writer makes sure that no question remains: both the diameter and the circumference are taken over-all." - though I'm not sure on what basis he sees that.)

Başlangıç olarak, verilen çapın oluşturacağı daireyi, verilen çevrenin oluşturacağı daireyle karşılaştırın: Çünkü bir çevre, çapın π katıdır, deniz olarak tanımladığımız gibi çapı 10 arşın olan 'saf' bir dairenin çevresi 10π arşın veya yaklaşık 31,4 arşın olur. Şimdi, denizimize atfedilen çevre sadece 30 arşın olduğundan, çapı 30/π veya yaklaşık 9,55 arşın olan daha küçük bir daireyi temsil eder. Veya tablo haline getirmek için: ```Daire A: ~9,55 arşın çap, 30 arşın çevre Daire B: 10 arşın çap, ~31,4 arşın çevre ``` Verilen bu durumda, yaklaşık 0,45 arşın (18 inçlik bir arşında yaklaşık sekiz inç - önemli bir fark) kadar farklılık gösteren iki çapımız var. Denizin fiziksel bir nesne olduğunu ve sonsuz küçük bir çizgiyle sınırlanmış bir daire olmadığını bildiğimizden, denizin bir miktar kalınlığı olması gerektiğini güvenle anlayabiliriz; bu gerekçeyle, daha kısa boyutu iç ölçüm, daha uzun boyutu dış ölçüm olarak almak ve bunun bizi nereye götürdüğüne bakmak mantıksız olmaz. Çaplardaki farkı ikiye bölmek, denizimizin etrafındaki duvarı en az 0,225 arşın kalınlığında yapar - yani, on sekiz inçlik bir arşın varsayarsak, denizin her iki ucunda yaklaşık dört inç. Bunun böyle olduğunu varsaymak ve denizin dört inç kalınlığında olduğunu söylemek için herhangi bir yetkimiz var mı? Bundan birkaç ayet sonra 1 Krallar 7:26'da bunu bize açıkça veriyor: Kalınlığı bir karıştı ve ağzı bir kâsenin ağzı gibi, bir zambak çiçeği gibiydi. İki bin bat su alıyordu. Bir ölçü birimi olarak bir karış genellikle üç ila dört inç arasında verilir. ('İncil'deki Pi Sayısı' sitesi, bu tür argümanlara karşı başka bir yerde bağlantı vererek şu ifadeyi veriyor: "Yazar, hiçbir soru kalmadığından emin olur: hem çap hem de çevre genel olarak alınır." - ancak bunun hangi temele dayandığından emin değilim.)

With PHP 7.2, ```each``` is deprecated. The documentation says: Warning This function has been DEPRECATED as of PHP 7.2.0. Relying on this function is highly discouraged. How can I update my code to avoid using it? Here are some examples: * ```$ar = $o->me; reset($ar); list($typ, $val) = each($ar); ``` * ```$out = array('me' => array(), 'mytype' => 2, '_php_class' => null); $expected = each($out); ``` * ```for(reset($broken);$kv = each($broken);) {...} ``` * ```list(, $this->result) = each($this->cache_data); ``` * ```// iterating to the end of an array or a limit > the length of the array $i = 0; reset($array); while( (list($id, $item) = each($array)) || $i < 30 ) { // code $i++; } ``` When I execute the code on PHP 7.2 I receive the following error: Deprecated: The each() function is deprecated. This message will be suppressed on further calls

PHP 7.2 ile ```each``` kullanım dışı bırakıldı. Belgelerde şöyle deniyor: Uyarı Bu fonksiyon PHP 7.2.0'dan itibaren KULLANIM DIŞI bırakılmıştır. Bu fonksiyona güvenmek kesinlikle önerilmez. Kullanmaktan kaçınmak için kodumu nasıl güncelleyebilirim? İşte bazı örnekler: * ```$ar = $o->me; reset($ar); list($typ, $val) = each($ar); ``` * ```$out = array('me' => array(), 'mytype' => 2, '_php_class' => null); $expected = each($out); ``` * ```for(reset($broken);$kv = each($broken);) {...} ``` * ```list(, $this->result) = each($this->cache_data); ``` * ```// bir dizinin sonuna veya dizinin uzunluğundan büyük bir sınıra kadar yineleme $i = 0; reset($array); while( (list($id, $item) = each($array)) || $i < 30 ) { // kod $i++; } ``` Kodu PHP 7.2'de çalıştırdığımda şu hatayı alıyorum: Kullanım dışı bırakıldı: each() fonksiyonu kullanım dışı bırakıldı. Bu mesaj sonraki çağrılarda bastırılacaktır

* For your first two example cases, you could use ```key()``` and ```current()``` to assign the values you need. ```$ar = $o->me; // reset isn't necessary, since you just created the array $typ = key($ar); $val = current($ar); ``` * ```$out = array('me' => array(), 'mytype' => 2, '_php_class' => null); $expected = [key($out), current($out)]; ``` In those cases, you can use ```next()``` to advance the cursor afterward, but it may not be necessary if the rest of your code doesn't depend on that. * For the third case, I'd suggest just using a ```foreach()``` loop instead and assigning ```$kv``` inside the loop. ```foreach ($broken as $k => $v) { $kv = [$k, $v]; } ``` * For the fourth case, it looks like the key is disregarded in ```list()```, so you can assign the current value. ```$this->result = current($this->cache_data); ``` Like the first two cases, it may be necessary to advance the cursor with ```next()``` depending on how the rest of your code interacts with ```$this->cache_data```. * Fifth can be replaced with a ```for()``` loop. ```reset($array); for ($i = 0; $i < 30; $i++) { $id = key($array); $item = current($array); // code next($array); } ```

* İlk iki örnek durumunuz için, ihtiyacınız olan değerleri atamak için ```key()``` ve ```current()``` kullanabilirsiniz. ```$ar = $o->me; // diziyi yeni oluşturduğunuz için sıfırlama gerekli değildir $typ = key($ar); $val = current($ar); ``` * ```$out = array('me' => array(), 'mytype' => 2, '_php_class' => null); $expected = [key($out), current($out)]; ``` Bu durumlarda, imleci sonradan ilerletmek için ```next()``` kullanabilirsiniz, ancak kodunuzun geri kalanı buna bağlı değilse gerekli olmayabilir. * Üçüncü durum için, bunun yerine bir ```foreach()``` döngüsü kullanmanızı ve ```$kv```'yi döngü içinde atamanızı öneririm. ```foreach ($broken as $k => $v) { $kv = [$k, $v]; } ``` * Dördüncü durum için, ```list()``` içinde anahtarın göz ardı edildiği anlaşılıyor, bu nedenle geçerli değeri atayabilirsiniz. ```$this->result = current($this->cache_data); ``` İlk iki durum gibi, kodunuzun geri kalanının ```$this->cache_data``` ile nasıl etkileşime girdiğine bağlı olarak imleci ```next()``` ile ilerletmek gerekebilir. * Beşincisi bir ```for()``` döngüsü ile değiştirilebilir. ```reset($array); for ($i = 0; $i < 30; $i++) { $id = key($array); $item = current($array); // kod next($array); } ```

Can someone please give an explanation of different egg preparations?

Birisi lütfen farklı yumurta hazırlama yöntemlerini açıklayabilir mi?

Sure, here are different preparations of eggs: 1. Fried Eggs: * Sunny Side Up -- Not flipped, unbroken yolk. The top of the egg is just barely set. * Basted -- Sunny Side Up, hot fat spooned over until the white surrounding the yolk is opaque. * Over Easy / lite -- Flipped, whites fully cooked, unbroken yolk, yolk runny. * Over medium -- flipped, whites fully cooked, unbroken yolk, yolk creamy (not completely runny). * Over Medium Well -- Flipped, unbroken yolk, yolk cooked to have a firm but wet-appearing center. * Over Hard -- Flipped, broken, fully-cooked yolk. * Over Well -- Flipped, intact, fully-cooked yolk. * Broken / Lightly Scrambled -- Broken in pan and gently stirred while cooking - yolk and whites should not be mixed entirely. * Scrambled Eggs -- Made in many different ways. Generally the eggs are mixed in a bowl before being put into the pan, and often stirred while cooking. Some recipes add fat to the eggs in the form of milk, * cream, butter, or oil. A distinction can be made between Wet/Loose or Dry, which refers to the degree of doneness. 2. Omelettes: * Filled Omelette -- Eggs mixed before cooking, possibly with added fat as in Scrambled Eggs. Cooked in fat in a saute pan; when set but the interior still wet, previously-cooked fillings (cheese, onions, mushrooms, peppers, tomatoes...) are added, and the eggs folded over into a half-moon shape. * Spanish Omelette / Western Omelette -- Same as filled, but the egg mixture is poured over the fillings in a hot pan and cooked, thus incorporating the fillings into the egg. * Fluffy Omelette -- Whites and yolks beaten separately. Yolks are gently folded into the whites without breaking the structure of the whites. Optional toppings are added. Cooked slowly in a pan, or baked (an electric frying pan with a lid works well for this preparation). * French Omelette -- Cooked soft & creamy with no color on the egg. Omelette is folded 1/3 in the pan, knocked to the edge so it can be rolled out onto the plate. It ends up being folded into thirds and is very creamy and soft. 3. Boiled: Cooked in shell in water for a timed period. Some people will refer to degree of doneness by cooking time, i.e., a &quot;3-minute egg&quot; is soft-boiled with some runny white around the yolk. Some recipes call for eggs to be added to boiling water, others to be started in cold water. In the cold-water start, the pot may be left on the heat or removed when the water reaches a boil. The eggs may be shocked in ice water when removed. * Soft -- Yolk runny, potentially with slight unset white around the yolk. * Medium -- White completely set, yolk firm but with a dark, wet appearance. * Hard -- Yolk completely set and pale yellow. 4. Poached: Egg cooked, out of shell, in water, stock, or other liquid -- excluding fats or oils -- at a temperature in the range of 160-180˚F (70-82˚C). There are possible degrees of doneness, however the typical poached egg has a runny but warm and thickened yolk and fully-set white. 5. Coddled: An egg that has been very lightly cooked (poached eggs are sometimes considered coddled). This can either be accomplished with an egg coddler or cooking an egg in its shell with water that is slightly below boiling point. 6. Shirred: An egg cooked in an oven at the low-mid 300's˚F (~160˚C), contained in a ramekin, until the whites are just set and the yolk is runny but thickened. Often butter or another fat is placed on top before cooking. 7. Steamed: Very similar to shirred eggs, but the ramekin is covered with some aluminum foil and put in a steamer for 7-15 minutes. 8. In a basket: Eggs fried in a hole made in a slice of bread. 9. deep fried Moo shu- using a strainer to drop small drops of egg into hot oil in a wok and stir. Frying in vegetables and/optionally meat or another protein then consume on mandarin pancakes with your choice of sauce.

Elbette, işte yumurtaların farklı hazırlanma şekilleri: 1. Kızarmış Yumurtalar: * Güneşli Tarafı Yukarı -- Çevrilmemiş, kırılmamış sarısı. Yumurta sadece üstten hafifçe pişmiş olur. * Yağda Pişirilmiş -- Güneşli Tarafı Yukarı, sarının etrafındaki beyazı opaklaşana kadar üzerine sıcak yağ dökülür. * Kolay / Hafif -- Çevrilmiş, beyazı tamamen pişmiş, sarısı kırılmamış, sarısı akıcı. * Orta -- çevrilmiş, beyazı tamamen pişmiş, sarısı kırılmamış, sarısı krema kıvamında (tamamen akıcı değil). * Orta İyi -- Çevrilmiş, sarısı kırılmamış, sarısı pişmiş ancak ıslak görünümlü bir merkezi var. * Sert -- Çevrilmiş, kırılmış, tamamen pişmiş sarısı. * İyi -- Çevrilmiş, sağlam, tamamen pişmiş sarısı. * Kırık / Hafif Çırpılmış -- Tavada kırılmış ve pişerken hafifçe karıştırılmış - sarısı ve beyazı tamamen karıştırılmamalıdır. * Çırpılmış Yumurtalar -- Birçok farklı şekilde yapılır. Genellikle yumurtalar tavaya konmadan önce bir kapta karıştırılır ve genellikle pişerken karıştırılır. Bazı tarifler yumurtalara süt, * krema, tereyağı veya yağ şeklinde yağ ekler. Pişirme derecesini ifade eden Islak/Geç veya Kuru arasında bir ayrım yapılabilir. 2. Omletler: * Dolu Omlet -- Yumurtalar pişirmeden önce karıştırılır, Çırpılmış Yumurtalarda olduğu gibi yağ eklenebilir. Bir sote tavasında yağda pişirilir; pişince ancak içi hala ıslakken, önceden pişirilmiş dolgular (peynir, soğan, mantar, biber, domates...) eklenir ve yumurtalar yarım ay şeklinde katlanır. * İspanyol Omleti / Batı Omleti -- Dolu omlet ile aynıdır, ancak yumurta karışımı sıcak bir tavada dolguların üzerine dökülür ve pişirilir, böylece dolgular yumurtaya dahil edilir. * Kabarık Omlet -- Beyazlar ve sarılar ayrı ayrı çırpılır. Sarılar, beyazların yapısını bozmadan beyazlara yavaşça katlanır. İsteğe bağlı soslar eklenir. Bir tavada yavaşça pişirilir veya fırınlanır (kapaklı bir elektrikli kızartma tavası bu hazırlık için iyi çalışır). * Fransız Omleti -- Yumurtada renk olmadan yumuşak ve kremamsı pişirilir. Omlet tavada 1/3 katlanır, kenara vurularak tabağa yuvarlanabilir. Sonunda üçte birine katlanır ve çok kremamsı ve yumuşaktır. 3. Haşlanmış: Kabuklu olarak suda belirli bir süre pişirilir. Bazı insanlar pişirme süresine göre pişirme derecesinden bahseder, yani bir "3 dakikalık yumurta", sarının etrafında biraz akıcı beyazı olan yumuşak haşlanmıştır. Bazı tarifler yumurtaların kaynar suya eklenmesini, diğerleri ise soğuk suda başlatılmasını gerektirir. Soğuk suda başlatmada, su kaynama noktasına ulaştığında tencere ateşte bırakılabilir veya kaldırılabilir. Yumurtalar çıkarıldığında buzlu suda şoklanabilir. * Yumuşak -- Sarısı akıcı, sarının etrafında hafifçe pişmemiş beyaz olabilir. * Orta -- Beyazı tamamen pişmiş, sarısı sert ancak koyu, ıslak görünümlü. * Sert -- Sarısı tamamen pişmiş ve soluk sarı. 4. Haşlanmış: Yumurta, kabuğundan çıkarılmış olarak, su, et suyu veya diğer sıvılarda -- yağlar veya yağlar hariç -- 160-180˚F (70-82˚C) aralığında bir sıcaklıkta pişirilir. Pişirme dereceleri olabilir, ancak tipik haşlanmış yumurtanın akıcı ancak ılık ve koyulaşmış bir sarısı ve tamamen pişmiş bir beyazı vardır. 5. Haşlanmış: Çok hafifçe pişirilmiş bir yumurta (haşlanmış yumurtalar bazen haşlanmış olarak kabul edilir). Bu, bir yumurta haşlama kabı ile veya bir yumurtayı kaynama noktasının biraz altındaki suyla kabuğunda pişirerek yapılabilir. 6. Shirred: Beyazlar tam olarak pişene ve sarısı akıcı ancak koyulaşana kadar, bir ramekinde bulunan 300'lerin˚F (~160˚C) düşük-orta sıcaklığında bir fırında pişen bir yumurta. Genellikle pişirmeden önce üzerine tereyağı veya başka bir yağ konur. 7. Buharda Pişmiş: Shirred yumurtalara çok benzer, ancak ramekin alüminyum folyo ile kapatılır ve 7-15 dakika buharda pişirilir. 8. Sepette: Bir dilim ekmekte açılan bir delikte kızartılmış yumurtalar. 9. derin yağda kızartılmış Moo shu- bir süzgeç kullanarak küçük yumurta damlalarını bir woktaki sıcak yağa damlatmak ve karıştırmak. Sebzelerde ve isteğe bağlı olarak et veya başka bir proteinle kızartın, ardından seçtiğiniz sosla mandalina kreplerinde tüketin.

I'm running a relatively small one-man business in the software sector. I just started and am trying to create a larger portfolio. For that, I offer some friends free services. I found a few reasons to send these clients €0,- invoices, mostly similar to the reasons to send 100% discount invoices to charity funds that I gave here: * Clarity about what has to be done and when * No transfers (as I would have with a 0% discount bill and returning the money as a gift) And also: * With an invoice I have more distinguishable clients which makes that I have more chance on getting a better certificate from the state (doesn't matter how it exactly works, this is an advantage) Suppose that these clients won't have a problem with the €0,- invoices, could there be any reason for me to not send them? I ask this, because I've never seen people sending invoices like this, and I can only see advantages.

Yazılım sektöründe nispeten küçük bir tek kişilik işletme yönetiyorum. Yeni başladım ve daha büyük bir portföy oluşturmaya çalışıyorum. Bunun için bazı arkadaşlarıma ücretsiz hizmetler sunuyorum. Bu müşterilere 0 € fatura göndermek için birkaç neden buldum, çoğunlukla burada hayır kurumlarına %100 indirimli fatura gönderme nedenlerine benzer: * Ne yapılması gerektiği ve ne zaman yapılması gerektiği konusunda netlik * Transfer yok (0% indirimli fatura ile paramı hediye olarak iade edeceğim için) Ve ayrıca: * Bir fatura ile daha ayırt edilebilir müşterilerim olur, bu da devletten daha iyi bir sertifika alma şansımın daha yüksek olduğu anlamına gelir (tam olarak nasıl çalıştığı önemli değil, bu bir avantajdır) Bu müşterilerin 0 € faturalarıyla ilgili bir sorun yaşamayacağını varsayarsak, onlara göndermeme nedenim olabilir mi? Bunu soruyorum çünkü daha önce hiç kimsenin bu şekilde fatura gönderdiğini görmedim ve sadece avantajlarını görebiliyorum.

It depends on the tax system that applies to you, but there can be consequences, and they can be very severe. Generally economic activity is defined as oriented on profit, so giving anything for free could qualify as self-promotion or donation. In Poland, for example, only some costs of the company spend on promotion can be considered as tax costs. So in worst case you could end with tax office refusing to acknowledge, for example, 50% of your expenses as tax costs. You would end up with fine and penalty percentages. With donation, the danger is even greater. There was a case of baker who was giving the unsold bread to charity for free. He was told to pay the VAT from the bread that was given for free (from the price it was normally being sold - but the tax officer is free to estimate the basis price as he/she wants). With penalty percentages the sum was so big, that he has become insolvent. However, the obligation to pay VAT was only in case of wares, not services, and the law has changed recently, but in other countries the regulations may be even stricter. There is also a potential consequence if you receive something for free. It could be interpreted as income and you would have to pay income tax from the value estimated by tax officer. Assuming, analyse your local law, consult a tax specialist and be sure you exactly want what you are doing before issuing €0 invoices.

Size uygulanan vergi sistemine bağlıdır, ancak sonuçları olabilir ve bunlar çok ciddi olabilir. Genellikle ekonomik faaliyet kâr odaklı olarak tanımlanır, bu nedenle herhangi bir şeyi ücretsiz vermek kendini tanıtma veya bağış olarak nitelendirilebilir. Örneğin Polonya'da, şirketin tanıtım için yaptığı harcamaların yalnızca bir kısmı vergi maliyeti olarak kabul edilebilir. Bu nedenle en kötü durumda, örneğin giderlerinizin %50'sini vergi maliyeti olarak kabul etmeyi reddeden bir vergi dairesiyle karşılaşabilirsiniz. Para cezası ve ceza yüzdeleriyle sonuçlanırsınız. Bağışla birlikte tehlike daha da büyüktür. Satılmayan ekmeği hayır kurumlarına ücretsiz veren bir fırıncı vakası vardı. Ücretsiz verilen ekmekten KDV ödemesi gerektiği söylendi (normalde satıldığı fiyattan - ancak vergi görevlisi temel fiyatı istediği gibi tahmin etmekte özgürdür). Ceza yüzdeleriyle birlikte toplam o kadar büyük oldu ki iflas etti. Ancak KDV ödeme yükümlülüğü yalnızca mallar için geçerliydi, hizmetler için değil ve yasa yakın zamanda değişti, ancak diğer ülkelerde düzenlemeler daha da katı olabilir. Ücretsiz bir şey alırsanız da potansiyel bir sonuç vardır. Gelir olarak yorumlanabilir ve vergi görevlisi tarafından tahmin edilen değer üzerinden gelir vergisi ödemek zorunda kalabilirsiniz. Varsayarak, yerel yasalarınızı analiz edin, bir vergi uzmanına danışın ve 0 € fatura düzenlemeden önce tam olarak ne yapmak istediğinizden emin olun.

In regards to Error handling in PHP -- As far I know there are 3 styles: * ```die()```or ```exit()``` style: ```$con = mysql_connect("localhost","root","password"); if (!$con) { die('Could not connect: ' . mysql_error()); } ``` * ```throw Exception``` style: ``` if (!function_exists('curl_init')) { throw new Exception('need the CURL PHP extension. Recomplie PHP with curl'); } ``` * ```trigger_error()``` style: ```if(!is_array($config) && isset($config)) { trigger_error('Error: config is not an array or is not set', E_USER_ERROR); } ``` Now, in the PHP manual all three methods are used. * What I want to know is which style should I prefer & why? * Are these 3 drop in replacements of each other & therefore can be used interchangeably? Is it just me or everyone thinks PHP error handling options are just too many to the extent it confuses php developers?

PHP'de Hata İşlemeyle ilgili olarak -- Bildiğim kadarıyla 3 stil var: * ```die()``` veya ```exit()``` stili: ```$con = mysql_connect("localhost","root","password"); if (!$con) { die('Could not connect: ' . mysql_error()); } ``` * ```throw Exception``` stili: ``` if (!function_exists('curl_init')) { throw new Exception('need the CURL PHP extension. Recomplie PHP with curl'); } ``` * ```trigger_error()``` stili: ```if(!is_array($config) && isset($config)) { trigger_error('Error: config is not an array or is not set', E_USER_ERROR); } ``` Şimdi, PHP kılavuzunda üç yöntem de kullanılıyor. * Bilmek istediğim, hangi stili tercih etmem gerektiği ve neden? * Bu 3'ü birbirinin yerine kullanabilir miyiz ve bu nedenle birbirinin yerine kullanılabilir mi? Sadece ben miyim yoksa herkes PHP hata işleme seçeneklerinin çok fazla olduğunu ve PHP geliştiricilerini şaşırttığını mı düşünüyor?

The first one should never be used in production code, since it's transporting information irrelevant to end-users (a user can't do anything about "Cannot connect to database"). You throw Exceptions if you know that at a certain critical code point, your application can fail and you want your code to recover across multiple call-levels. ```trigger_error()``` lets you fine-grain error reporting (by using different levels of error messages) and you can hide those errors from end-users (using ```set_error_handler()```) but still have them be displayed to you during testing. Also ```trigger_error()``` can produce non-fatal messages important during development that can be suppressed in production code using a custom error handler. You can produce fatal errors, too (```E_USER_ERROR```) but those aren't recoverable. If you trigger one of those, program execution stops at that point. This is why, for fatal errors, Exceptions should be used. This way, you'll have more control over your program's flow: ```// Example (pseudo-code for db queries): $db->query('START TRANSACTION'); try { while ($row = gather_data()) { $db->query('INSERT INTO `table` (`foo`,`bar`) VALUES(?,?)', ...); } $db->query('COMMIT'); } catch(Exception $e) { $db->query('ROLLBACK'); } ``` Here, if ```gather_data()``` just plain croaked (using ```E_USER_ERROR``` or ```die()```) there's a chance, previous ```INSERT``` statements would have made it into your database, even if not desired and you'd have no control over what's to happen next.

İlk olanı asla üretim kodunda kullanılmamalıdır, çünkü son kullanıcılarla alakasız bilgi taşır ("Veritabanına bağlanılamıyor"). Uygulamanızın belirli bir kritik kod noktasında başarısız olabileceğini ve kodunuzun birden fazla çağrı düzeyinde kurtarılmasını istediğinizi biliyorsanız, İstisnalar atarsınız. ```trigger_error()``` size ince taneli hata bildirimi (farklı hata mesajı düzeylerini kullanarak) yapma olanağı tanır ve bu hataları son kullanıcılardan gizleyebilirsiniz (```set_error_handler()``` kullanarak) ancak yine de test sırasında size gösterilebilir. Ayrıca ```trigger_error()```, özel bir hata işleyicisi kullanılarak üretim kodunda bastırılabilen, geliştirme sırasında önemli olan ölümcül olmayan mesajlar üretebilir. Ölümcül hatalar da üretebilirsiniz (```E_USER_ERROR```) ancak bunlar kurtarılamaz. Bunlardan birini tetiklerseniz, program yürütme o noktada durur. Bu nedenle, ölümcül hatalar için İstisnalar kullanılmalıdır. Bu şekilde, programınızın akışı üzerinde daha fazla kontrolünüz olur: ```// Örnek (veritabanı sorguları için sözde kod): $db->query('START TRANSACTION'); try { while ($row = gather_data()) { $db->query('INSERT INTO `table` (`foo`,`bar`) VALUES(?,?)', ...); } $db->query('COMMIT'); } catch(Exception $e) { $db->query('ROLLBACK'); } ``` Burada, ```gather_data()``` dümdüz bozulursa (```E_USER_ERROR``` veya ```die()``` kullanılarak), istenmese bile önceki ```INSERT``` ifadelerinin veritabanınıza girme ihtimali vardır ve bundan sonra ne olacağı üzerinde hiçbir kontrolünüz olmaz.

How do I change the author and committer name/email for multiple commits?

Birden fazla commit için yazar ve commit eden kişinin adını/e-postasını nasıl değiştiririm?

Here is the solution, but be careful if you have a multi-user repository - this will change all commits to have the same (new) author and committer. ``` git filter-branch -f --env-filter " GIT_AUTHOR_NAME='Newname' GIT_AUTHOR_EMAIL='new@email' GIT_COMMITTER_NAME='Newname' GIT_COMMITTER_EMAIL='new@email' " HEAD ``` Changing the author (or committer) would require rewriting all of the history. If you're okay with that and think it's worth it then you should check out git filter-branch. The manual page includes several examples to get you started. Also note that you can use environment variables to change the name of the author, committer, dates, etc. -- see the "Environment Variables" section of the git manual page. Specifically, you can fix all the wrong author names and emails for all branches and tags with this command (source: GitHub help): ``` #!/bin/sh git filter-branch --env-filter ' OLD_EMAIL="[email protected]" CORRECT_NAME="Your Correct Name" CORRECT_EMAIL="[email protected]" if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ] then export GIT_COMMITTER_NAME="$CORRECT_NAME" export GIT_COMMITTER_EMAIL="$CORRECT_EMAIL" fi if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ] then export GIT_AUTHOR_NAME="$CORRECT_NAME" export GIT_AUTHOR_EMAIL="$CORRECT_EMAIL" fi ' --tag-name-filter cat -- --branches --tags ``` For using alternative history filtering tool `git filter-repo`, you can first install it and construct a `git-mailmap` according to the format of `gitmailmap`. ``` Proper Name <[email protected]> Commit Name <[email protected]> ``` And then run filter-repo with the created mailmap: ``` git filter-repo --mailmap git-mailmap ```

İşte çözüm, ancak çok kullanıcılı bir deponuz varsa dikkatli olun - bu, tüm commit'leri aynı (yeni) yazara ve commit'çiye sahip olacak şekilde değiştirecektir. ``` git filter-branch -f --env-filter " GIT_AUTHOR_NAME='YeniAd' GIT_AUTHOR_EMAIL='yeni@eposta' GIT_COMMITTER_NAME='YeniAd' GIT_COMMITTER_EMAIL='yeni@eposta' " HEAD ``` Yazarı (veya commit'çiyi) değiştirmek, tüm geçmişi yeniden yazmayı gerektirir. Bunu kabul ediyorsanız ve buna değdiğini düşünüyorsanız, git filter-branch'e göz atmalısınız. Kılavuz sayfasında başlamanıza yardımcı olacak birkaç örnek yer almaktadır. Ayrıca, yazarın, commit'çinin, tarihlerin vb. adını değiştirmek için ortam değişkenlerini kullanabileceğinizi de unutmayın. Git kılavuz sayfasının "Ortam Değişkenleri" bölümüne bakın. Özellikle, bu komutla tüm dallar ve etiketler için tüm yanlış yazar adlarını ve e-postalarını düzeltebilirsiniz (kaynak: GitHub yardım): ``` #!/bin/sh git filter-branch --env-filter ' ESKİ_EPOSTA="eski-epostanız@örnek.com" DOĞRU_AD="Doğru Adınız" DOĞRU_EPOSTA="doğru-epostanız@örnek.com" if [ "$GIT_COMMITTER_EMAIL" = "$ESKİ_EPOSTA" ] then export GIT_COMMITTER_NAME="$DOĞRU_AD" export GIT_COMMITTER_EMAIL="$DOĞRU_EPOSTA" fi if [ "$GIT_AUTHOR_EMAIL" = "$ESKİ_EPOSTA" ] then export GIT_AUTHOR_NAME="$DOĞRU_AD" export GIT_AUTHOR_EMAIL="$DOĞRU_EPOSTA" fi ' --tag-name-filter cat -- --branches --tags ``` Alternatif geçmiş filtreleme aracı `git filter-repo` kullanmak için öncelikle onu yükleyebilir ve `gitmailmap` formatına göre bir `git-mailmap` oluşturabilirsiniz. ``` Gerçek Ad <gerç[email protected]> Commit Adı <[email protected]> ``` Ardından, oluşturulan mailmap ile filter-repo'yu çalıştırın: ``` git filter-repo --mailmap git-mailmap ```

This summer I will be taking a rather inherently dangerous multi-day hike by myself. I was considering buying a flare gun since I will be out of cellular range unless there is something more modern and equally reliable. Any suggestions?

Bu yaz kendi başıma oldukça tehlikeli bir çok günlük yürüyüşe çıkacağım. Hücresel aralık dışında olacağım için bir işaret fişeği tabancası almayı düşünüyordum, daha modern ve eşit derecede güvenilir bir şey yoksa. Herhangi bir öneriniz var mı?

In increasing order of complexity and price you have, * Personal Locator Beacons Personal locator beacons are high-powered (typically, 5 watts) devices designed primarily to send out a personalized emergency distress signal. They generally require an open view of the sky to transmit successfully. * Satellite Messengers (Like a Garmin inReach) Much like PLBs, satellite messengers are handheld transmitting devices that are useful in backcountry areas far from reliable cell phone coverage. These user-friendly devices allow you to communicate short text messages and/or your location coordinates with friends or family back home so you can report on your trip’s status or, in an emergency, send calls for help. * Satellite Phones A satellite telephone, satellite phone, or satphone is a type of mobile phone that connects to orbiting satellites instead of terrestrial cell sites. They provide similar functionality to terrestrial mobile telephones; voice, short messaging service and low-bandwidth internet access are supported through most systems. None of these are a substitute for good judgement and the electronics can fail or run out of batteries, but they would be the modern equivalent of a flare gun.

Karmaşıklık ve fiyat sırasına göre şunlar var: * Kişisel Konum Belirleyicileri Kişisel konum belirleyicileri, öncelikle kişiselleştirilmiş bir acil durum sıkıntı sinyali göndermek için tasarlanmış yüksek güçlü (genellikle 5 watt) cihazlardır. Genellikle başarılı bir şekilde iletmek için gökyüzünün açık bir görüşüne ihtiyaç duyarlar. * Uydu Habercileri (Garmin inReach Gibi) PLB'lere çok benzeyen uydu habercileri, güvenilir cep telefonu kapsamından uzaktaki kırsal alanlarda kullanışlı olan el tipi iletim cihazlarıdır. Bu kullanıcı dostu cihazlar, kısa metin mesajları ve/veya konum koordinatlarınızı evdeki arkadaşlarınızla veya ailenizle iletişim kurmanıza olanak tanır, böylece yolculuğunuzun durumunu bildirebilir veya acil bir durumda yardım çağrısı gönderebilirsiniz. * Uydu Telefonları Bir uydu telefonu, uydu telefonu veya uydu telefonu, karasal hücresel siteler yerine yörüngedeki uydulara bağlanan bir tür cep telefonudur. Karasal cep telefonlarına benzer işlevsellik sağlarlar; çoğu sistemde ses, kısa mesaj servisi ve düşük bant genişliğine sahip internet erişimi desteklenir. Bunların hiçbiri sağduyunun yerini almaz ve elektronik cihazlar arızalanabilir veya pilleri bitebilir, ancak bunlar bir işaret fişeğinin modern karşılığı olacaktır.