[QE 2017] Grzegorz Galezowski - Prostota nie jest łatwa

PROSTOTA
NIE JEST ŁATWA
GRZEGORZ GAŁĘZOWSKI
MOTOROLA SOLUTIONS

proste!
proste!
proste!
proste!
proste!
proste!

public static List<T> QuickSort<T>(List<T> values)
where T : IComparable
{
if (values.Count == 0)
return new List<T>();
T firstElement = values[0];
var smallerElements = new List<T>();
var largerElements = new List<T>();
for (int i = 1; i < values.Count; i++)
{
var elem = values[i];
if (elem.CompareTo(firstElement) < 0)
smallerElements.Add(elem);
else
largerElements.Add(elem);
}
var result = new List<T>();
result.AddRange(QuickSort(smallerElements.ToList()));
result.Add(firstElement);
result.AddRange(QuickSort(largerElements.ToList()));
return result;
}
Source: http://fsharpforfunandprofit.com/posts/fvsc-quicksort/

let rec quicksort list =
match list with
| [] ->
[]
| firstElem::otherElements ->
let smallerElements =
otherElements
|> List.filter (fun e -> e < firstElem)
|> quicksort
let largerElements =
otherElements
|> List.filter (fun e -> e >= firstElem)
|> quicksort
List.concat [smallerElements; [firstElem]; largerElements]
Source: http://fsharpforfunandprofit.com/posts/fvsc-quicksort/

To powinno pasować do mojego
mentalnego modelu!

public interface X
{
}
public interface X {
}

ŁATWE
minimalny wysiłek prowadzący do celu

PROSTE
usunięcie wszystkiego z wyjątkiem tego, co istotne

if(lid.OldUpdateParameters == null)
{
lid.OldUpdateParameters = new UpdateParameters(lid.UpdateParams);
}
if(cadence.HasValue) // there is ack
{
cadenceToSend = cadence.Value;
}
else
{
if (lid.OldUpdateParameters.MinFrequencyUpdateEnabled.HasValue &&
lid.OldUpdateParameters.MinFrequencyUpdateEnabled.Value)
{
cadenceToSend = lid.OldUpdateParameters.MinFrequencyUpdate;
}
}
if (distance.HasValue) // there is ack
{
distanceToSend = distance.Value;
}
else
{
if (lid.OldUpdateParameters.DistanceUpdateEnabled.HasValue &&
lid.OldUpdateParameters.DistanceUpdateEnabled.Value)
{
distanceToSend = lid.OldUpdateParameters.DistanceUpdate;
}
}
if (maxTime.HasValue) // there is ack
{
maxTimeToSend = maxTime.Value;
}
else
{
if (lid.OldUpdateParameters.MaxFrequencyUpdateEnabled.HasValue &&
lid.OldUpdateParameters.MaxFrequencyUpdateEnabled.Value)
{
maxTimeToSend = lid.OldUpdateParameters.MaxFrequencyUpdate;
}
}

YOU AREN’T GONNA NEED IT
PAGE 46

KOSZT WYTWORZENIA
analiza, programowanie, testowanie

KOSZT OPÓŹNIENIA
innych funkcjonalności

KOSZT UTRZYMANIA
inne funkcjonalności stają się droższe

KOSZT NAPRAWY
przedawniona wiedza/technologia

{
}
{
}
else
{
{
}
}
{
}
else
{
{
}
}
{
}
else
{
{
}
}
!!?

{
}
{
}
else
{
{
}
}
{
}
else
{
{
}
}
{
}
else
{
{
}
}
YAGNI!!

Yagni (...) does not apply to effort
to make the software easier to
modify.
Martin Fowler

Yagni is only a viable strategy
if the code is easy to change.
Martin Fowler

Można to zrobić prościej!Można to zrobić prościej!

PROBLEM
brak wspólnego zrozumienia prostoty

PROBLEM
brak sposobu, żeby osiągnąć prostotę

CZTERY ZASADY
PROSTEGO DESIGNU
PAGE 70

WSZYSTKIE TESTY PRZECHODZĄ
PRZEKAZANA INTENCJA
BRAK NADMIAROWOŚCI
MINIMALNA LICZBA KLAS I METOD

double CmToM(double value)
{
return value/100;
}
double PercentToFraction(double value)
{
return value/100;
}

When 5 things need to change for
the same reason, Shalloway will find
at most 4
PRAWO SHALLOWAYA

When 5 things need to change for
the same reason, Shalloway will find
at most 4
Kiedy koncepcyjnie tę samą zmianę
trzeba wprowadzić w 4 miejscach,
Shalloway znajdzie maksymalnie 3.

PRZEKAZANA INTENCJA
MINIMALNA LICZBA KLAS I METOD
BRAK NADMIAROWOŚCI

Mamy narzędzia do analizy przepływu…

…lecz nie do analizy intencji

if(message.AgeBit == 1)
{
foreach(var codeword in message.Codewords)
{
if(codeword.Id == 0x12)
{
currentCodewords.Add(codeword);
}
}
}

if(IsMostRecent(message))
{
{
if(IsVoice(codeword))
{
voiceSequence.Add(codeword);
}
}
}

if(message.IsMostRecent())
{
{
if(codeword.IsVoice())
{
voiceSequence.Add(codeword);
}
}
}

{
message.AggregateVoiceInto(voiceSequence);
}

{
message.AggregateVoiceInto(voiceSequence);
}
ABSTRAKCJE

USUŃ
NADMIAROWOŚĆ
PRZEKAŻ
INTENCJE
STRUKTURA
ABSTRAKCJE
http://blog.thecodewhisperer.com/2013/12/07/putting-an-age-old-battle-to-rest/

USUŃ
NADMIAROWOŚĆ
PRZEKAŻ
INTENCJE
STRUKTURAPOTRZEBNE
NAZWY
ABSTRAKCJE

USUŃ
NADMIAROWOŚĆ
PRZEKAŻ
INTENCJE
STRUKTURA
ABSTRAKCJE
WIDAĆ
NADMIAROWOŚĆ
NA WYŻSZYM
POZIOMIE
POTRZEBNE
NAZWY

LogLevel
LogFileName
InfoLog
+ AddInfo(string message)
ErrorLog
+ AddError(string message)

LogLevel
LogFileName
InfoLog
+ AddInfo(string message)
ErrorLog
Log
+ AddDebug(string message)

LogLevel
LogFileName
Log
+ AddDebug(string message)

authentication.SetLogin(login);
authentication.SetPassword(password);
authentication.LogIn();

authentication.LogInWith(credentials);

MAKSYMALNA SPÓJNOŚĆ
BRAK NADMIAROWOŚCI
MINIMALNE POWIĄZANIA

STAN 1
STAN 2
Foo1(), Foo2()
Bar1(), Bar2()

STAN 1
STAN 2
Bar1(), Bar2()
Foo1(), Foo2()

STAN 1
Foo1(), Foo2()
STAN 2
Bar1(), Bar2()

NIE MA SYSTEMU BEZ POWIĄZAŃ

ZBYT MOCNE
TRUDNO ROZDZIELIĆ KLASY
DUŻY WPŁYW MAŁYCH ZMIAN
F
A E
C

ZBYT LEKKIE
SŁABSZA CZYTELNOŚĆ
F
A E
C

PRZYPADKOWE
KOD PSUJE SIĘ W NIEOCZEKIWANYCH MIEJSCACH
b.GetC().GetD().DoSomething()
DCB
A

ZE ZBYT WIELOMA KLASAMI
TRUDNE DO OGARNIĘCIA
MAŁA STABILNOŚĆ
D F
B
A E
C

It is okay to want something that
is "stupidly simple" but not at the
expense of being simply stupid!
Brad Appleton

MOTOROLA, MOTO, MOTOROLA SOLUTIONS and the Stylized M Logo are trademarks or registered trademarks of Motorola Trademark Holdings, LLC
and are used under license. All other trademarks are the property of their respective owners. © 2010 Motorola, Inc. All rights reserved.
iProtect Classification: Public

[QE 2017] Grzegorz Galezowski - Prostota nie jest łatwa

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (14)

Similar to [QE 2017] Grzegorz Galezowski - Prostota nie jest łatwa

Similar to [QE 2017] Grzegorz Galezowski - Prostota nie jest łatwa (20)

More from Future Processing

More from Future Processing (20)

Recently uploaded

Recently uploaded (20)

[QE 2017] Grzegorz Galezowski - Prostota nie jest łatwa

Editor's Notes