0

Useful software engineering stuff

by Deepak Dhakal 9. August 2019 23:37

mlubinsky.github.com

https://habr.com/ru/company/skillbox/blog/462979/

Fibonacci

https://habr.com/ru/post/449616/

https://habr.com/ru/post/450594/

http://www.oranlooney.com/post/fibonacci/

https://news.ycombinator.com/item?id=19216356

Monads

https://blog.kabir.sh/posts/inventing-monads.html

Algo

https://github.com/TheAlgorithms/Python

https://github.com/30-seconds/30-seconds-of-python-code

https://m.stopa.io/10-offers-100-days-the-journey-16a0407b8d95 interview https://habr.com/ru/post/454264/ . Inteview

https://habr.com/ru/post/455260/ Merkel’s tree

https://hackernoon.com/20-string-coding-interview-questions-for-programmers-6b6735b6d31c

https://medium.com/@fahimulhaq/14-patterns-to-ace-any-coding-interview-question-c5bb3357f6ed

https://www.solutionfactory.in/posts/Floyd-Cycle-Detection-Algorithm-in-Java Cycle detection

https://docs.google.com/spreadsheets/d/1GOO4s1NcxCR8a44F0XnsErz5rYDxNbHAHznu4pJMRkw/edit#gid=0

http://web.stanford.edu/class/archive/cs/cs161/cs161.1168/

http://web.stanford.edu/class/cs166/handouts/100%20Suggested%20Final%20Project%20Topics.pdf

https://www.youtube.com/channel/UC_79TBgKFlEwFp345dYF7ag

https://robertheaton.com/2014/05/02/jaccard-similarity-and-minhash-for-winners/

https://cses.fi/book/ . Competitive programming book

https://www.amazon.com/dp/1793296634 Algo Book

https://www.byte-by-byte.com/google-interview/

https://courses.csail.mit.edu/iap/interview/materials.php

http://www.cs.sjtu.edu.cn/~jiangli/teaching/CS222/files/materials/Algorithm%20Design.pdf Algo book

https://www.byte-by-byte.com

https://www.youtube.com/watch?v=9clnwaqOU2E string algo

https://www.globalsoftwaresupport.com/most-common-programming-interview-questions-in-2019/

https://github.com/devAmoghS/Practice-Problems

https://habr.com/ru/post/442352/ Бинарные деревья поиска

https://www.youtube.com/watch?v=lpO_arK69vg LCA

https://habr.com/ru/post/438512/ алгоритм Хаффмана

https://djhworld.github.io/hyperloglog/

http://blog.amynguyen.net/?p=853

https://eddmann.com/posts/depth-first-search-and-breadth-first-search-in-python/

http://www.java67.com/2018/05/top-75-programming-interview-questions-answers.html

http://www.algorithmsilluminated.org/

https://habr.com/ru/post/112222/ heap

https://habr.com/ru/post/437702/ Разбор задачи с собеседования в Google: синонимичные запросы

http://algorithms.wtf/

http://opendatastructures.org/

https://algoexpert.io/rachit Use “rachit” as coupon code to get 30% off

https://algs4.cs.princeton.edu/home/

https://www.youtube.com/watch?v=TeZqKnC2gvA Visitor design pattern

https://medium.freecodecamp.org/unmasking-bitmasked-dynamic-programming-25669312b77b

https://techiedelight.quora.com/500-Data-Structures-and-Algorithms-interview-questions-and-their-solutions

https://blog.usejournal.com/i-interviewed-at-six-top-companies-in-silicon-valley-in-six-days-and-stumbled-into-six-job-offers-fe9cc7bbc996

https://www.businessinsider.fr/us/microsoft-new-developer-interview-process-2018-12

https://stackabuse.com/programming-interview-questions/

https://bradfieldcs.com/algos/

http://rachitiitr.blogspot.com/

https://www.youtube.com/watch?v=4NIb9l3imAo

disjoint set union (DSU) или Union-Find. https://habr.com/ru/post/104772/ создать быструю структуру, которая поддерживает следующие операции:

MakeSet(X) — внести в структуру новый элемент X, создать для него множество размера 1 из самого себя. Find(X) — возвратить идентификатор множества, которому принадлежит элемент X. В качестве идентификатора мы будем выбирать один элемент из этого множества — представителя множества. Гарантируется, что для одного и того же множества представитель будет возвращаться один и тот же, иначе невозможно будет работать со структурой: не будет корректной даже проверка принадлежности двух элементов одному множеству if (Find(X) == Find(Y)).

Unite(X, Y) — объединить два множества, в которых лежат элементы X и Y, в одно новое.

http://iolivia.me/posts/4-bloom-filter-part-3/ Bloom filter

https://stackoverflow.com/questions/2936213/explain-how-finding-cycle-start-node-in-cycle-linked-list-work

https://stackoverflow.com/questions/41515081/algorithm-find-all-permutations-of-string-a-in-string-b

https://www.youtube.com/playlist?list=PLMCXHnjXnTnvo6alSjVkgxV-VH6EPyvoX . system design questions

https://www.youtube.com/watch?v=bBPHpH8aKjw look fo links here!

https://blog.sqreen.io/demystifying-radix-trees/ . Radix tree https://news.ycombinator.com/item?id=18921058 . Radix trees

https://stackoverflow.com/questions/11897088/diameter-of-binary-tree-better-design

http://www.interviewdruid.com/ https://github.com/parineeth/tbboci-3rd-edition-python https://www.amazon.com/dp/1983861189

https://www.algoexpert.io/product

https://www.hackerrank.com/

https://www.interviewbit.com/

https://www.jeffcarp.com/posts/2018-how-to-solve-every-software-engineering-interview-question/

https://habr.com/ru/post/457042/ . Tree traversal using 2 threads (Java)

LCA

https://en.wikipedia.org/wiki/Lowest_common_ancestor https://sites.google.com/site/mytechnicalcollection/algorithms/trees/lca-of-binary-tree https://stackoverflow.com/questions/1484473/how-to-find-the-lowest-common-ancestor-of-two-nodes-in-any-binary-tree

https://www.youtube.com/channel/UCcAWgbpROQrPok18E6UozWw/videos

https://www.facebook.com/tusharroy25/

https://github.com/mission-peace/interview/tree/master/src/com/interview

https://github.com/donnemartin/interactive-coding-challenges

https://github.com/alexhagiopol/cracking-the-coding-interview

https://github.com/charulagrl/data-structures-and-algorithms

https://github.com/thundergolfer/interview-with-python/tree/master/solutions/python

https://github.com/anubhavshrimal/Data_Structures_Algorithms_In_Python

https://github.com/bt3gl/Python-and-Algorithms-and-Data-Structures/

https://blog.finxter.com/python-interview-questions/

https://stackabuse.com/graph-data-structure-interview-questions/

http://www.java67.com/2018/05/top-75-programming-interview-questions-answers.html

https://www.quora.com/How-do-I-learn-algorithms-2

https://skillupper.com/

https://moultano.wordpress.com/2018/11/08/minhashing-3kbzhsxyg4467-6/

https://moultano.wordpress.com/2018/11/08/minhashing-3kbzhsxyg4467-6/

https://habr.com/post/430788/

http://www.benfrederickson.com/distance-metrics/

https://www.youtube.com/watch?v=1CxyVdA_654 Running mediam in stream

https://www.youtube.com/watch?v=IHsX70r-fIQ Max sub-sequence in string

https://www.quora.com/How-do-I-start-learning-or-strengthen-my-knowledge-of-data-structures-and-algorithms?redirected_qid=2804253

https://medium.com/educative/3-month-coding-interview-bootcamp-904422926ce8

https://stratos.seas.harvard.edu/files/stratos/files/periodictabledatastructures.pdf

https://hackernoon.com/10-data-structure-algorithms-and-programming-courses-to-crack-any-coding-interview-e1c50b30b927

https://www.bitdegree.org/user/course/data-structures-and-algorithms

https://news.ycombinator.com/item?id=18236396 . Favorite algos

https://aryaboudaie.com/interviews/python/technical/2017/11/06/python-for-interviews.html

https://www.youtube.com/watch?v=vS4Zn1a9KUc

https://www.youtube.com/watch?v=7Hlb8YX2-W8

http://csc.kth.se/~jsannemo/slask/main.pdf Book

https://cses.fi/book.pdf Book

http://e-maxx.ru/index.php

https://blog.datopia.io/2018/11/03/hitchhiker-tree/

https://github.com/tayllan/awesome-algorithms

https://github.com/karan/Projects

http://cslibrary.stanford.edu/

<http://www.idryman.org/blog/2017/07/04/learn-hash-table-the-hard-way/ https://medium.com/engineering-brainly/locality-sensitive-hashing-explained-304eb39291e4 Local sensitive hash https://sagi.io/2017/07/bloom-filters-for-the-perplexed/https://news.ycombinator.com/item?id=15346337 https://stackoverflow.com/questions/3260653/algorithm-to-find-top-10-search-terms/3260905#3260905

http://yucoding.blogspot.com/2017/01/leetcode-question-range-sum-query.html http://massivealgorithms.blogspot.com/http://ruslanledesma.com/ http://algorithms.tutorialhorizon.com/

https://www.youtube.com/watch?v=GiCWlXEhht8 https://www.youtube.com/watch?v=il_t1WVLNxk https://www.youtube.com/watch?v=e5D3NepYvLE https://www.youtube.com/watch?v=eaYX0Ee0Kcg https://www.youtube.com/watch?v=zGv3hOORxh0

http://quiz.geeksforgeeks.org/amazons-most-frequently-asked-interview-questions-set-2/ https://www.geeksforgeeks.org/amazons-asked-interview-questions/

https://www.youtube.com/watch?v=eaYX0Ee0Kcg https://www.udemy.com/11-essential-coding-interview-questions/?couponCode=AMAZON2

Google interview

https://habr.com/post/419945/

https://news.ycombinator.com/item?id=18374938

https://habr.com/company/google/blog/425279/

https://medium.com/@alexgolec/google-interview-questions-deconstructed-the-knights-dialer-f780d516f029

https://www.youtube.com/watch?v=5o-kdjv7FD0

https://interviewing.io/recordings

https://habr.com/post/419725/ Non-symmetric dime simulation

http://www.cmsmagazine.ru/library/items/programming/80-problems-with-it-interviews/

https://saru.science/tech/2017/01/18/judy-arrays.html Judy array

https://www.reddit.com/r/cpp/comments/9afpq7/whats_your_favorite_data_structure/

https://habr.com/post/420605/

https://discuss.codechef.com/questions/48877/data-structures-and-algorithms

https://hackernoon.com/50-data-structure-and-algorithms-interview-questions-for-programmers-b4b1ac61f5b0

https://en.wikipedia.org/wiki/Ant_on_a_rubber_rope

https://www.youtube.com/playlist?list=PLBZBJbE_rGRVnpitdvpdY9952IsKMDuev

Egg drop

https://habr.com/post/423679/

http://declanoller.com/2018/09/03/the-egg-drop-puzzle-brute-force-dynamic-programming-and-markov-decision-processes/

Find 1st element in rotated sorted array

def bs(lst, start, end):
   print ("start=",start, "end=", end)
   if start == end:  return start
   m = (start+end)//2
   print ("middle=",m, lst[m])

   if m < end and lst[m+1] < lst[m]:
      return m+1
   if m > start and lst[m] < lst[m-1]:
      return m

   if lst[end] > lst[m]:
      return bs(lst, start, m -1)
   else:
      return  bs(lst, m+1, end)

def find(l):
  start=0
  end=len(l)-1
  i= bs(l, start, end)
  return i

if __name__ =="__main__":
  print ("main")
  l1=[5,10,20, 1,2,3,4]
  print(l1)
  i=find(l1)
  print ("index=",i)

  l2=[20, 1,2,3,4]
  print(l2)
  i=find(l2)
  print ("index=",i)

Hash function and hashtable

https://habr.com/ru/company/otus/blog/448992/

https://honest.engineering/posts/hash-functions-survival-guide

https://en.wikipedia.org/wiki/Hash_function

https://rcoh.me/posts/hash-map-analysis/

https://attractivechaos.wordpress.com/2018/10/01/advanced-techniques-to-implement-fast-hash-tables/

https://softwareengineering.stackexchange.com/questions/49550/which-hashing-algorithm-is-best-for-uniqueness-and-speed

https://rcoh.me/posts/hash-map-analysis/

https://www.reddit.com/r/programming/comments/9lw5pu/advanced_techniques_to_implement_fast_hash_tables/

Consistent Hashing

https://www.toptal.com/big-data/consistent-hashing

https://medium.com/@dgryski/consistent-hashing-algorithmic-tradeoffs-ef6b8e2fcae8 Consistent hashing

https://dzone.com/articles/simple-magic-consistent

Locality sensitive hashing

https://en.wikipedia.org/wiki/Locality-sensitive_hashing

http://unboxresearch.com/articles/lsh_post1.html

https://dev.to/s_awdesh duplicates in array, dual pivot sort

Dynamic programming

https://habr.com/post/418867/

https://habr.com/post/423939/

https://ngoldbaum.github.io/posts/dynamic-programming/

https://news.ycombinator.com/item?id=20285242

https://avikdas.com/2019/06/24/dynamic-programming-for-machine-learning-hidden-markov-models.html

https://avikdas.com/2019/04/15/a-graphical-introduction-to-dynamic-programming.html

https://medium.freecodecamp.org/unmasking-bitmasked-dynamic-programming-25669312b77b

https://blogarithms.github.io/articles/2019-03/cracking-dp-part-one

https://www.geeksforgeeks.org/min-cost-path-dp-6/

https://macnovicetomaster.wordpress.com/2019/06/05/dynamic-programming-practice-problems/

Dynamic Programming- Python implementation of Min Cost Path on grid problem

def minCost(cost, m, n):

# Instead of following line, we can use int tc[m+1][n+1] or 
# dynamically allocate memoery to save space. The following 
# line is used to keep te program simple and make it working 
# on all compilers. 
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)] 
  
tc[0][0] = cost[0][0] 
  
# Initialize first column of total cost(tc) array 
for i in range(1, m+1): 
    tc[i][0] = tc[i-1][0] + cost[i][0] 
  
# Initialize first row of tc array 
for j in range(1, n+1): 
    tc[0][j] = tc[0][j-1] + cost[0][j] 
  
# Construct rest of the tc array 
for i in range(1, m+1): 
    for j in range(1, n+1): 
        tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j] 
  
return tc[m][n] 

Driver program to test above functions

cost = [[1, 2, 3], 
        [4, 8, 2], 
        [1, 5, 3]] 
print(minCost(cost, 2, 2)) 

Count number of ways to reach mat[m-1][n-1] from mat[0][0] in a matrix mat[][]

Returns The number of way from top-left to mat[m-1][n-1]

def countPaths(m, n):

dp = [[0 for i in range(m + 1)]  
         for j in range(n + 1)] 
  
for i in range(1, m + 1): 
    for j in range(1, n + 1): 
        if (i == 1 or j == 1): 
            dp[i][j] = 1
        else: 
            dp[i][j] = (dp[i - 1][j] + 
                        dp[i][j - 1])              
  
return dp[m][n] 

Driver code

if name ==”main”:

n = 5
m = 5
print(countPaths(n, m)) 

https://hackernoon.com/dynamic-programming-for-brute-forcers-36f26c2466cf>

https://medium.com/@codingfreak/top-50-dynamic-programming-practice-problems-4208fed71aa3

https://lukasmericle.github.io/dynprotut/

Others

http://www.cmsmagazine.ru/library/items/programming/80-problems-with-it-interviews/

Regular expression

https://regexr.com/

https://news.ycombinator.com/item?id=20608032

https://deniskyashif.com/implementing-a-regular-expression-engine/

https://deniskyashif.com/2019/02/17/implementing-a-regular-expression-engine/

https://www.youtube.com/watch?v=l3hda49XcDE

https://nikic.github.io/2012/06/15/The-true-power-of-regular-expressions.html

https://rcoh.me/posts/no-magic-regular-expressions-part-3/

https://medium.com/@cdiggins/beyond-regular-expressions-an-introduction-to-parsing-context-free-grammars-ee77bdab5a92

Inerpretators Compiles

https://bernsteinbear.com/blog/bytecode-interpreters/

https://news.ycombinator.com/item?id=18821475

Tags:

General | java | SQL

0

Frequently Forgotten Fundamental Facts about Software Engineering

by Deepak Dhakal 15. March 2012 18:43

 

Complexity

C1. For every 10-percent increase in problem complexity, there is a 100-percent increase in the software solution�s complexity. That's not a condition to try to change (even though reducing complexity is always desirable); that's just the way it is. (For one explanation of why this is so, see RD2 in the section "Requirements and design.")

 

People

P1. The most important factor in attacking complexity is not the tools and techniques that programmers use but rather the quality of the programmers themselves.

P2. Good programmers are up to 30 times better than mediocre programmers, according to "individual differences" research. Given that their pay is never commensurate, they are the biggest bargains in the software field.

 

Tools and techniques

T1. Most software tool and technique improvements account for about a 5- to 30-percent increase in productivity and quality. But at one time or another, most of these improvements have been claimed by someone to have "order of magnitude" (factor of 10) benefits. Hype is the plague on the house of software.

T2. Learning a new tool or technique actually lowers programmer productivity and product quality initially. You achieve the eventual benefit only after overcoming this learning curve.

T3. Therefore, adopting new tools and techniques is worthwhile, but only if you (a) realistically view their value and (b) use patience in measuring their benefits.

 

Quality

Q1. Quality is a collection of attributes. Various people define those attributes differently, but a commonly accepted collection is portability, reliability, efficiency, human engineering, testability, understandability, and modifiability.

Q2. Quality is not the same as satisfying users, meeting requirements, or meeting cost and schedule targets. However, all these things have an interesting relationship: User satisfaction = quality product + meets requirements + delivered when needed + appropriate cost.

Q3. Because quality is not simply reliability, it is about much more than software defects.

Q4. Trying to improve one quality attribute often degrades another. For example, attempts to improve efficiency often degrade modifiability.

 

Reliability

RE1. Error detection and removal accounts for roughly 40 percent of development costs. Thus it is the most important phase of the development life cycle.

RE2. There are certain kinds of software errors that most programmers make frequently. These include off-by-one indexing, definition or reference inconsistency, and omitting deep design details. That is why, for example, N-version programming, which attempts to create multiple diverse solutions through multiple programmers, can never completely achieve its promise.

RE3. Software that a typical programmer believes to be thoroughly tested has often had only about 55 to 60 percent of its logic paths executed. Automated support, such as coverage analyzers, can raise that to roughly 85 to 90 percent. Testing at the 100-percent level is nearly impossible.

RE4. Even if 100-percent test coverage (see RE3) were possible, that criteria would be insufficient for testing. Roughly 35 percent of software defects emerge from missing logic paths, and another 40 percent are from the execution of a unique combination of logic paths. They will not be caught by 100-percent coverage (100-percent coverage can, therefore, potentially detect only about 25 percent of the errors!).

RE5. There is no single best approach to software error removal. A combination of several approaches, such as inspections and several kinds of testing and fault tolerance, is necessary.

RE6. (corollary to RE5) Software will always contain residual defects, after even the most rigorous error removal. The goal is to minimize the number and especially the severity of those defects.

 

Efficiency

EF1. Efficiency is more often a matter of good design than of good coding. So, if a project requires efficiency, efficiency must be considered early in the life cycle.

EF2. High-order language (HOL) code, with appropriate compiler optimizations, can be made about 90 percent as efficient as the comparable assembler code. But that statement is highly task dependent; some tasks are much harder than others to code efficiently in HOL.

EF3. There are trade-offs between size and time optimization. Often, improving one degrades the other.

 

Maintenance

M1. Quality and maintenance have an interesting relationship (see Q3 and Q4).

M2. Maintenance typically consumes about 40 to 80 percent (60 percent average) of software costs. Therefore, it is probably the most important life cycle phase.

M3. Enhancement is responsible for roughly 60 percent of software maintenance costs. Error correction is roughly 17 percent. So, software maintenance is largely about adding new capability to old software, not about fixing it.

M4. The previous two facts constitute what you could call the "60/60" rule of software.

M5. Most software development tasks and software maintenance tasks are the same—except for the additional maintenance task of "understanding the existing product." This task is the dominant maintenance activity, consuming roughly 30 percent of maintenance time. So, you could claim that maintenance is more difficult than development.

 

Requirements and design

RD1. One of the two most common causes of runaway projects is unstable requirements. (For the other, see ES1.)

RD2. When a project moves from requirements to design, the solution process's complexity causes an explosion of "derived requirements." The list of requirements for the design phase is often 50 times longer than the list of original requirements.

RD3. This requirements explosion is partly why it is difficult to implement requirements traceability (tracing the original requirements through the artifacts of the succeeding lifecycle phases), even though everyone agrees this is desirable.

RD4. A software problem seldom has one best design solution. (Bill Curtis has said that in a room full of expert software designers, if any two agree, that's a majority!) That's why, for example, trying to provide reusable design solutions has so long resisted significant progress.

 

Reviews and inspections

RI1. Rigorous reviews commonly remove up to 90 percent of errors from a software product before the first test case is run. (Many research findings support this; of course, it's extremely difficult to know when you've found 100 percent of a software product's errors!)

RI2. Rigorous reviews are more effective, and more cost effective, than any other error-removal strategy, including testing. But they cannot and should not replace testing (see RE5).

RI3. Rigorous reviews are extremely challenging to do well, and most organizations do not do them, at least not for 100 percent of their software artifacts.

RI4. Post-delivery reviews are generally acknowledged to be important, both for determining customer satisfaction and for process improvement, but most organizations do not perform them. By the time such reviews should be held (three to 12 months after delivery), potential review participants have generally scattered to other projects.

 

Reuse

REU1. Reuse-in-the-small (libraries of subroutines) began nearly 50 years ago and is a well-solved problem.

REU2. Reuse-in-the-large (components) remains largely unsolved, even though everyone agrees it is important and desirable.

REU3. Disagreement exists about why reuse-in-the-large is unsolved, although most agree that it is a management, not technology, problem (will, not skill). (Others say that finding sufficiently common subproblems across programming tasks is difficult. This would make reuse-in-the-large a problem inherent in the nature of software and the problems it solves, and thus relatively unsolvable).

REU4. Reuse-in-the-large works best in families of related systems, and thus is domain dependent. This narrows its potential applicability.

REU5. Pattern reuse is one solution to the problems inherent in code reuse.

 

Estimation

ES1. One of the two most common causes of runaway projects is optimistic estimation. (For the other, see RD1.)

ES2. Most software estimates are performed at the beginning of the life cycle. This makes sense until we realize that this occurs before the requirements phase and thus before the problem is understood. Estimation therefore usually occurs at the wrong time.

ES3. Most software estimates are made, according to several researchers, by either upper management or marketing, not by the people who will build the software or by their managers. Therefore, the wrong people are doing estimation.

ES4. Software estimates are rarely adjusted as the project proceeds. So, those estimates done at the wrong time by the wrong people are usually not corrected.

ES5. Because estimates are so faulty, there is little reason to be concerned when software projects do not meet cost or schedule targets. But everyone is concerned anyway!

ES6. In one study of a project that failed to meet its estimates, the management saw the project as a failure, but the technical participants saw it as the most successful project they had ever worked on! This illustrates the disconnect regarding the role of estimation, and project success, between management and technologists. Given the previous facts, that is hardly surprising.

ES7. Pressure to achieve estimation targets is common and tends to cause programmers to skip good software process. This constitutes an absurd result done for an absurd reason.

 

Research

RES1. Many software researchers advocate rather than investigate. As a result, (a) some advocated concepts are worth less than their advocates believe and (b) there is a shortage of evaluative research to help determine the actual value of new tools and techniques.

There, that's my two cents' worth of software engineering fundamental facts. What are yours? I expect, if we can get a dialog going here, that there are a lot of similar facts that I have forgotten—or am not aware of. I'm especially eager to hear what additional facts you can contribute.

And, of course, I realize that some will disagree (perhaps even violently!) with some of the facts I've presented. I want to hear about that as well.

 

ref: http://www.computer.org/portal/web/buildyourcareer/fa035

 

Tags: , , ,

General | test

0

Playing sound using AVAudioPlayer in iPhone

by Deepak Dhakal 11. May 2009 12:34

Add a audio framwork AVFoundation using

#import and use code below to play a sound

 ########################### #########
AVAudioPlayer *myExampleSound;
NSString *myExamplePath = [[NSBundle mainBundle] pathForResource:@"horror" ofType:@"wav"];
myExampleSound =[[AVAudioPlayer alloc] initWithContentsOfURL:[NSURL fileURLWithPath:myExamplePath] error:NULL];
myExampleSound.delegate = self;
[myExampleSound play]; //play sound
//[myExampleSound stop]; you can stop like this
###########################################################

When you add a AVFoundation framwork, make sure to use absolute path.. Relative path is by default there and that gives compile error ..

Tags:

General | iPhone

0

“content encoding error” while using blogengine.net

by Deepak Dhakal 11. May 2009 10:49

 

While using BlogEngine.net you may run into “content encoding error” “The page you are trying to view cannot be shown because it uses an invalid or unsupported form of compression” this error, to resolve this, find

<add name=”CompressionModule” type=”BlogEngine.Core.Web.HttpModules.CompressionModule, BlogEngine.Core”/>

in your web.config file and comment this line of code. This error mostly arrives when you host blogengine.net site on GoDaddy.

Tags:

Blogging | General

Powered by BlogEngine.NET 1.5.0.7
Original Design by Laptop Geek, Adapted by onesoft